Face Recognition Algorithm Based on Fast Computation of Orthogonal Moments

Abstract

Face recognition is required in various applications, and major progress has been witnessed in this area. Many face recognition algorithms have been proposed thus far; however, achieving high recognition accuracy and low execution time remains a challenge. In this work, a new scheme for face recognition is presented using hybrid orthogonal polynomials to extract features. The embedded image kernel technique is used to decrease the complexity of feature extraction, then a support vector machine is adopted to classify these features. Moreover, a fast-overlapping block processing algorithm for feature extraction is used to reduce the computation time. Extensive evaluation of the proposed method was carried out on two different face image datasets, ORL and FEI. Different state-of-the-art face recognition methods were compared with the proposed method in order to evaluate its accuracy. We demonstrate that the proposed method achieves the highest recognition rate in different considered scenarios. Based on the obtained results, it can be seen that the proposed method is robust against noise and significantly outperforms previous approaches in terms of speed.

1. Introduction

Face recognition has been used in various fields, such as personal identification [1,2] descriptions of gender and gestures [3], victim identification, surveillance security systems, medical diagnosis, multimedia communication, and human–computer interfaces [4,5]. The face has different cues that help to uniquely identify an individual human. These cues have been widely utilized by authentication and verification algorithms to extract diverse discriminative features, achieving accurate identification [4,6]. The wide spectrum of facial features has enabled face recognition challenges to attract broad interest compared to other biometric systems, and it has become one of the most important topics of research [7,8,9]. In addition, the robustness of the face localization and normalization processes are considered the core of an efficient feature extraction process [10].

Even though many face recognition methods have been studied, system accuracy and processing time remain critical issues and need to be treated carefully. Generally, the results of well known methods do not provide the required accuracy with a fast execution time. Therefore, careful investigation of an accurate and fast face recognition method is required. Moreover, to the best of our knowledge, most of the existing works do not take into consideration the effect of noise in input images. Noise may appear mainly in non-cooperative applications, where the lighting conditions are beyond control.

In order to address the above-mentioned challenges, the present paper proposes a robust face recognition algorithm by using a kind of Hybrid Orthogonal Polynomials (HOPs), specifically, Squared Krawtchouk–Tchebichef polynomials (SKTP) [11], and a fast overlapping block processing algorithm for feature extraction. These HOPs have been used widely in the literature on image and signal processing because of their powerful capabilities in feature extraction. In addition, the use of the fast algorithm for overlapping block processing [12] provides the construction of auxiliary matrices, which virtually extends the original image and makes it possible to avoid time-consuming computation loops. The introduced solution reaps the benefits of adopting the SKTP model in multiple dimensions. The energy compaction and localization properties of the SKTP outperform the existing orthogonal polynomials (OPs) and other hybrid-form OPs, which helps to represent the images efficiently and reduces the computation cost of feature extraction. In addition, the extraction of moments from overlapped blocks increases the robustness of the features, which in turn increases the recognition rate. One of the main advantages of the proposed solution is its high robustness to noise in the input images. This is achieved by standard Gaussian smoothing implemented in a novel way: the Gaussian kernel is embedded into the moment calculation step, meaning that it does not increase the computation time.

1.1. Literature Review and Discussion

There are several well known classes of image feature extraction methods: deep learning methods, the eigenface and Fisher face methods, texture-based methods, and projection-based methods. This last approach “projects” facial images on a functional basis and uses these projection coefficients as features. The basis is usually formed by a set of orthogonal functions such as wavelets, harmonic functions or polynomials [2]. The method we propose in this paper falls into this category.

Deep learning-based approaches have a high level of recognition accuracy; however, they require a large amount of data to perform better than other methods and provide an extreme level of computational complexity [13,14,15,16,17]. In the OM-based methods, the features of faces can be computed effectively using Orthogonal Polynomials (OPs) [11]. In recent works, OPs and their moments have been intensively used for image analysis, shape descriptors, and pattern recognition [18]. In the moment domain, image components are represented in a transform domain, offering a powerful capability for analyzing them [11]. Orthogonal moments (OMs) can be defined as scalar quantities that are utilized to characterize the function and capture its significant features. In addition, they are the coordinates of an image in the orthogonal polynomial function [19,20]. Furthermore, OMs have the ability to extract features from images that have different geometric invariants, such as translation, scaling, and rotation [2].

Different types of moments are used in image processing systems. First, geometric moments have been introduced over other kinds of moments due to their explicit geometric meaning and simplicity [21]. Zernike and Pseudo-Zernike moments are utilized to represent the image with minimal redundancy of information [22], while fractional quaternion Zernike moments have been used for detection of color image copy–move forgery [23] because fractional-order polynomials can represent functions better than integer-order polynomials [2]. Fractional-order Zernike moments have been used efficiently in plant disease recognition [24]. Legendre moments were used in [25] to reduce block artifacts. For image analysis, Zernike and Legendre polynomials are used as kernel functions for Zernike and Legendre moments, respectively [26]. In addition to the ability of Zernike moments to store information about images with minimum redundancy, they have the property of invariance. However, these moments require image coordinate transformations for discrete situations, as they are defined specifically in the continuous domain [27].

Recently, discrete orthogonal moments have been adopted to overcome the computational cost of image analysis of continuous moments [28]. Mukundan presented a set of moments to analyze the image using discrete Tchebichef polynomials [29]. In addition, Tchebyshev moments have been implemented in watermarking algorithms and image encryption algorithms [30]. For face recognition, an adaptively weighted patch of pseudo-Zernike moments has been used [31]. Different OMs have been used in this field, such as higher-order OMs [32], Fourier–Mellin moments [33], rotation-invariant complex Zernike moments [34], discrete Krawtchouk moments [35], Tchebichef moments [36], orthogonal exponent Fourier moments [37], 2D orthogonal Gaussian–Hermite moments [38], and 2D Krawtchouk moments [21]. The 2D Krawtchouk OMs provided good results in conditions with noise, tilt, and changes in expression [39]. In comparison with other moments, Gaussian–Hermite moments are considered very robust against noise [28,40]. Gaussian–Hermite moments can bne used as a set of useful features to capture the facial expression from face images [39,41]. Generally, the extraction methods of image features are classified into two groups: global features-based methods (termed Holistic approaches [42]) and local features-based methods (termed Component-based methods [42] or Block Processing-based methods). The former method captures the features from an entire image of a human face, while the local feature extraction method can extract features from certain areas of the face image, such as the eyes, mouth, and chin [39]. There are various global feature extraction methods, such as Eigenfaces [43], Fisher faces [44], Linear Discriminant Analysis [45], Discrete Cosine Transform [46], Independent Component Analysis [47], and others. The global features-based method has achieved superior performance when implemented with different imaging conditions [48].

In block processing-based methods the extraction of image features can be performed locally using OMs, meaning that processing of the image blocks takes place after partitioning. Block processing is implemented in different applications of signal processing in which signals (images and videos) are partitioned into blocks. These blocks are converted to the transform domain in order to extract the features, which are stored in a memory location equivalent to the image block for processing in the next steps [12]. In general, block processing-based methods perform better than holistic-based methods [42]. Local Binary Patterns is one of local feature extraction methods, it is used to partition face image into sub-images where feature distribution is extracted and fused together [49]. This method is a good descriptor to represent local structures [50,51]. A combination of global and local methods, that is called a Fusion (or hybrid) algorithm, is also adopted to achieve a desired face recognition with high accuracy [39,48].

Block processing that represents local feature extraction provides high accuracy at the expense of increased computation cost. Different types of transforms have been used for this purpose. Gabor transform [52] has been used widely to extract the local features [53,54], alhough the extracted face features are particularly sensitive to noise. In addition, face recognition methods that use local feature are dependent on face localization and the registration model [39]. In [55], an algorithm for face recognition was proposed in which Krawtchouk polynomials with different values of parameters were used for noise-free and noisy environments. This algorithm can overcome the problem of numerical instability by utilizing symmetry properties across polynomials’ diagonals to address the effect of their parameter on feature extraction. The computation cost of this method is considered relatively high. Partitioning of the images using image block processing extracts the blocks of the images and processes them sequentially. This process is not sequential from the perspective of the memory, however, which is considered a key drawback in terms of computation performance and results in an essential gap between CPU speed and memory. Accessing the entire matrix in sequence maintains the spatial locality, although it causes more cache misses and replacements [12]. Exclusion of further processes accelerates the extraction of local features; in other words, the extraction of local features from the image blocks by discrete transformation decreases computational complexity. This is called the fast overlapping block processing algorithm [12].

1.2. Contributions

The main contributions of this paper are: (1) design of a robust face recognition method for multiple imaging conditions following the shape-invariant concept; (2) use of powerful hybrid OPs called SKTP to extract image features; (3) utilization of a fast-overlapping block processing algorithm for feature extraction in order to decrease computation time; and (4) application of an embedded filter to suppress noise and maintain the speed of feature extraction.

The rest of this paper is organized as follows: Section 2 introduces the preliminaries of the fundamental OPs used to form the SKTP; in Section 3, the methodology is presented; Section 4 introduces and discusses the obtained results; finally, in Section 5, the conclusions of this work are drawn.

2. Preliminaries of Orthogonal Polynomials and Moments

In this section, the mathematical model of the utilized orthogonal polynomials and the computation of their moments for two-dimensional signals are presented.

2.1. Squared Krawtchouk–Tchebichef Polynomials

The concept of discrete orthogonal polynomials is to project a signal on the orthogonal polynomial basis. In image analysis, we consider 2D signals. Discrete orthogonal polynomials are used to describe the signal efficiently and without redundancy [56]. Discrete orthogonal polynomials are defined using two variables (x and n), forming a two-dimensional matrix. The variable x represents the index (coordinate) of the signal, and the variable n represents the order of the polynomial. The coefficients of the matrix are the values of the discrete orthogonal polynomials. In this paper, Squared Krawtchouk—Tchebichef Polynomials (SKTP) and their moments are used. SKTPs are formed from the combination of the Krawtchouk polynomials (KPs) and Tchebichef polynomials (TPs). This combination results in a polynomial with the properties of both KP and TP, i.e., an SKTP shows localization and energy compaction compared to other types of polynomials [57]. Thus, SKTPs leverage the accuracy of face recognition. The nth order of the SKTP $S_n(x;p)$ is defined in terms of KP (K) and TP (T) for $n,x=0,1,\cdots ,N-1$ as follows [11]:

$$S_n(x;p)=\sum _{i=0}^{N-1}\sum _{j=0}^{N-1}\sum _{l=0}^{N-1}{K}_j(i;p)K_l(n;p)T_j\left(x\right)T_l\left(i\right)$$

(1)

where p represents the polynomial parameter. The definition of SKTP can be written in matrix form as follows:

$${\mathbf{R}}_S={\left({\mathbf{R}}_K{\mathbf{R}}_T\right)}^2$$

(2)

where ${\mathbf{R}}_K$ and ${\mathbf{R}}_T$ represent the matrices of the KP and TP.

Orthogonal polynomials can be efficiently calculated by recurrent relations, which is a way that is fast and prevents precision loss due to overflow/underflow. The algorithms used for evaluation of KP and TP in this paper are provided in Appendix A.

2.2. Squared Krawtchouk–Tchebichef Moments

It is well known that the discrete moments are considered essential tools in different applications [19,58]. Specifically, the discrete moments are used for signal representation due to their being, at least to an extent, robust to noise effects [59]. In addition, the moments are scalar quantities and as such are able to reveal the small changes that appear in signals [60]. For these reasons, discrete moments are utilized in face recognition. As mentioned earlier, the discrete moments are scalar quantities, and are produced for a 1D signal from the projection of the signal onto the discrete orthogonal polynomial basis functions. In addition, they can be produced for 2D signals (images) from the projection of the images on the discrete orthogonal polynomials’ basis images [56]. In this paper, Squared Krawtchouk–Tchebichef moments (SKTM) are used, and are computed as follows:

$$M_{SKTM}(n,m)=\sum _{x=0}^{N_x-1}\sum _{y=0}^{N_y-1}f(x,y)S_n(x;p,N_x)S_m(y;p,N_y)$$

(3)

Generally, discrete moments represent the descriptors (features) in two folds: the low-order moments and the high-order moments. The low-order moments preserve the signal information, while the high-order moments represent the details of the signal [60]. Thus, for feature extraction, the low order moments ($n_o$ and $m_o$) need to be utilized as follows:

$$\begin{array}{cc}\hfill n& =\frac{N_x}{2}-1,\frac{N_x}{2},\cdots ,\frac{N_x-n_o}{2},\frac{N_x-n_o}{2}-1\hfill \end{array}$$

(4)

$$\begin{array}{cc}\hfill m& =\frac{N_y}{2}-1,\frac{N_y}{2},\cdots ,\frac{N_y-m_o}{2},\frac{N_y-m_o}{2}-1\hfill \end{array}$$

(5)

The moments are computed using matrix multiplication as

$${\mathbf{M}}_{SKTM}={\mathbf{R}}_{Sy}\mathbf{I}{\mathbf{R}}_{Sx}^T$$

(6)

where ${(·)}^T$ represents the matrix transpose.

3. Methodology

In this section, the feature extraction process and the recognition process for face recognition are described. The flowchart of the proposed face recognition method is shown in Figure 1.

The feature extraction process is the main part of any recognition system. For the sake of accurate results, instead of using a global feature, local feature extraction is used to enable more efficient face recognition. Local features are considered more robust and leverage the recognition accuracy when compared to global features [61,62,63]. Therefore, in order to increase the robustness of recognition accuracy, the face image is partitioned into blocks with a block size of $B_{y_{size}}\times B_{x_{size}}$. The TP and KP are generated using the procedures in Appendices Appendix A.1 and Appendix A.2, respectively. Note that the KP is generated with a localization parameter p. After obtaining the two matrices of KP and TP, the SKTP matrices (${\mathbf{U}}_x$ / ${\mathbf{U}}_y$) are generated using Equation (2).

Most face recognition algorithms have concentrated on a collaborative scenario in a noise-free environment. In a noisy environment, the face recognition process is degraded and the face recognition accuracy is significantly affected. Thus, face image preprocessing is needed to reduce the noise effect without excessively increasing the computation cost. The use of embedded image kernels to reduce computation cost was proposed in [64], and we adopt this idea here. In order to embed a smoothing kernel in the generated SKTP matrices (${\mathbf{U}}_x$ / ${\mathbf{U}}_y$), Toeplitz matrices (${\mathbf{H}}_{xs}$ / ${\mathbf{H}}_{ys}$) are generated [65] using a Gaussian smoothing kernel:

$$\begin{array}{c}\hfill h_{xs}=\frac{1}{2\pi {\sigma }_x^2}{e}^{-\frac{x^2}{2{\sigma }_x^2}}\end{array}$$

(7)

$$\begin{array}{c}\hfill h_{ys}=\frac{1}{2\pi {\sigma }_y^2}{e}^{-\frac{y^2}{2{\sigma }_y^2}}\end{array}$$

(8)

where $\sigma$ determines the effective size of the kernel (most often ${\sigma }_x={\sigma }_y$). Thus, (${\mathbf{H}}_{xs}$ / ${\mathbf{H}}_{ys}$) can be generated as follows [65]:

$$\begin{array}{c}\hfill {\mathbf{H}}_{xs}=\left[\begin{array}{cccccc}{h}_{xs}^0& h_{xs}^1& \cdots & h_{xs}^m& 0& 0\\ 0& h_{xs}^0& h_{xs}^1& \cdots & h_{xs}^m& 0\\ ⋮& 0& h_{xs}^0& h_{xs}^1& \cdots & h_{xs}^m\\ 0& ⋮& 0& \ddots & \ddots & ⋮\\ 0& 0& ⋮& 0& h_x^0& h_x^1\\ 0& 0& 0& \cdots & 0& h_x^0\end{array}\right]\end{array}$$

(9)

$$\begin{array}{c}\hfill {\mathbf{H}}_{ys}=\left[\begin{array}{cccccc}{h}_{ys}^0& 0& 0& \cdots & 0& 0\\ h_{ys}^1& h_{ys}^0& 0& 0& \cdots & 0\\ ⋮& h_{ys}^1& h_{ys}^0& 0& \cdots & 0\\ h_{ys}^m& ⋮& h_{ys}^1& \ddots & \ddots & ⋮\\ 0& h_{ys}^m& ⋮& \ddots & h_{ys}^0& 0\\ 0& 0& h_{ys}^m& \cdots & h_{ys}^1& h_{ys}^0\end{array}\right]\end{array}$$

(10)

where m and l are the lengths of the smoothing kernels $h_{xs}$ and $h_{ys}$, respectively. To this end, the embedded SKTP matrices (${\mathbf{W}}_x$ / ${\mathbf{W}}_y$) can be formulated as follows [64]:

$$\begin{array}{c}\hfill {\mathbf{W}}_y={\mathbf{U}}_y{\mathbf{H}}_{ys},\end{array}$$

(11)

$$\begin{array}{c}\hfill {\mathbf{W}}_x={\mathbf{U}}_x{\mathbf{H}}_{xs}^T.\end{array}$$

(12)

After generating the SKTP matrices with embedded smoothing kernels, we are ready for the feature extraction step. However, the use of traditional methods to extract local features leads to a high computation cost [66], as they extract the local features directly from the small blocks. Most applications utilize non-overlapped block processing to extract local features. However, overlapped block processing increases the recognition accuracy [67,68,69]. Thus, in this paper, overlapped block processing is performed. It is well known that overlapped block processing increases the computation cost considerably. In order to overcome this problem, we utilize the fast overlapped block processing method presented in [12]. The main concept of fast overlapped block processing (FOBP) is based on the creation of auxiliary matrices that extend the image and eliminate the need for a nested loop. The elimination of the nested loops greatly reduces the computation cost of the feature extraction process.

Suppose an image $\mathbf{I}$ has $N_y$ rows and $N_x$ columns. The image is partitioned into overlapped blocks with a size of $B_{y_{size}}\times B_{x_{size}}$, with overlap size $O{V}_{x_{size}}$ in the x-direction and $O{V}_{y_{size}}$ in the y-direction such that the total blocks are equal to $Bl{k}_y\times Bl{k}_x=\frac{N_y}{B_{y_{size}}-2O{V}_{y_{size}}}\times \frac{N_x}{B_{x_{size}}-2O{V}_{x_{size}}}$. Suppose the matrix ${\mathbf{I}}_{\mathbf{B}}$ represents the extended image version of $\mathbf{I}$; it can be generated as follows [12]:

$${\mathbf{I}}_{\mathbf{B}}={\mathbf{E}}_y\mathbf{I}{\mathbf{E}}_x^T$$

(13)

where ${\mathbf{E}}_y$ and ${\mathbf{E}}_x$ are rectangular matrices with a size of $(B_{y_{size}}·Bl{k}_y\times N_y)$ and $(B_{x_{size}}·Bl{k}_x\times N_x)$, respectively. For further elucidation, the matrix ${\mathbf{E}}_y$ is provided by

(14)

where $\mathbb{I}$ represents the identity matrix, with a size of $B_{y_{size}}\times B_{y_{size}}$. Now, the moments for the overlapped block can be computed as follows:

$$\begin{array}{cc}\hfill \mathbf{M}& ={\mathbf{S}}_y{\mathbf{I}}_{\mathbf{B}}{\mathbf{S}}_x^T\hfill \end{array}$$

(15)

$$\begin{array}{cc}\hfill & ={\mathbf{S}}_y{\mathbf{E}}_y\mathbf{I}{\mathbf{E}}_x^T{\mathbf{S}}_x^T\hfill \end{array}$$

(16)

$$\begin{array}{cc}\hfill & ={\mathbf{Q}}_y\mathbf{I}{\mathbf{Q}}_x^T\hfill \end{array}$$

(17)

where ${\mathbf{Q}}_y={\mathbf{S}}_y{\mathbf{E}}_y$ and ${\mathbf{Q}}_x={\mathbf{S}}_x{\mathbf{E}}_x$. To obtain the matrices ${\mathbf{S}}_x$ and ${\mathbf{S}}_y$, they can be formulated as follows [12]:

$$\mathbf{S}=\mathbb{I}\otimes \mathbf{W}$$

(18)

where ⊗ represents the Kronecker product and $\mathbb{I}$ represents the identity matrix. Because these matrices are independent of the image, they are computed first, stored, and utilized repeatedly [12].

After generating the required matrices (${\mathbf{Q}}_x$ and ${\mathbf{Q}}_y$), the images are sent to the next stage for feature extraction and classification. Note that the extracted features are normalized.

After the normalized feature vector has been obtained, a label (ID) is applied to each input face image. The feature vector is considered as an input to the classifier. The classification itself is performed by a support vector machine (SVM) classifier. The SVM approach was chosen because of its ability to optimize the margin between two hyperplanes separating the classes [70]. In addition, SVM is suitable for recognition, as it is more robust to signal fluctuation than nearest-neighbor classifiers [71]. In this paper, LIB-SVM was applied [72].

4. Experiments and Analysis

In this section, two different datasets are employed to evaluate the performance of the face recognition algorithm. The datasets used in the experiments are the ORL [73] and FEI datasets [74]. The ORL Face Database from AT&T [73] is a well-known datset which has been used by many researchers for evaluation purposes. The ORL dataset includes 40 distinct classes (persons). Each class has ten images, which are acquired at different position and lighting conditions to form 400 images, and each image has a size of $92\times 112$ [75]. Figure 2 shows samples of the ORL face dataset.

For the ORL dataset, the block size in the x and y directions was set to 16 and 20, respectively. The overlap sizes in the x and y directions were set to {(0,0), (2,2), (4,4), (8,8)}. The size of the smoothing kernel was set to {3, 5, 7}. In addition, the test was performed with noise-free and noisy environments and with Gaussian and Salt and Pepper noise. The Gaussian noise was generated with the standard deviation 0.005, and 0.01, respectively. The Salt and Pepper noise was generated with densities 0.05 and 0.1. Figure 3 depicts samples of images with different types of noise.

Table 1. ORL recognition rates (%) under different parameters.

Environment	${\mathit{\sigma }}_{\mathit{smoothing}}$	Overlap Size
		(0,0)	(2,2)	(4,4)
Noise-free	0.5	97.73	97.68	97.65
	1.0	97.75	97.73	98.23
	1.5	97.78	97.58	97.98
Gaussian 0.005	0.5	97.73	97.70	97.55
	1.0	97.65	97.85	98.23
	1.5	97.78	97.70	97.98
Gaussian 0.010	0.5	97.70	97.63	97.68
	1.0	97.60	97.80	98.18
	1.5	97.60	97.60	98.00
Salt&Pepper 0.05	0.5	97.63	97.40	97.70
	1.0	97.50	97.85	97.95
	1.5	97.63	97.70	97.78
Salt&Pepper 0.10	0.5	97.53	97.00	97.35
	1.0	97.05	96.98	97.58
	1.5	97.18	96.90	97.28

summarizes the average results for 20 runs, and the detailed results of individual runs can be found in Appendix B.

For SVM implementation, we used LIB-SVM [72]. In the training phase, five-fold cross-validation was employed to obtain stable values of the SVM parameters.

First, an experiment was carried out for the proposed algorithm using two cases, with and without a smoothing kernel. This experiment was performed to highlight the effect of the smoothing kernel on the recognition accuracy. The experiment was performed for different overlap sizes of {(0,0), (2,2), (4,4)} and different environments (noise-free and noisy environments), as shown in

Table 2. ORL recognition rates (%) using the proposed approach with/without smoothing kernel.

Environment	Without Smoothing Kernel			With Smoothing Kernel
	Overlap Size			Overlap Size
	(0,0)	(2,2)	(4,4)	(0,0)	(2,2)	(4,4)
Noise-free	97.35	97.50	97.60	97.75	97.73	98.23
Gaussian 0.005	97.33	97.53	97.60	98.65	97.85	98.23
Gaussian 0.010	97.40	97.58	97.55	97.60	97.80	98.18
Salt&Pepper 0.05	97.60	97.60	97.58	97.50	97.85	97.95
Salt&Pepper 0.10	97.08	97.10	97.23	97.05	96.98	97.58
Average	97.35	97.46	97.51	97.51	97.64	98.03

. Note that the results reported in Table 2 represent the average results for 20 runs; the detailed results of individual runs can be found in Appendix C. The results show that the recognition accuracy of the proposed algorithm is higher with a smoothing kernel than that without, with average recognition accuracy showing an improvement ratio of ∼0.5%.

Another experiment was performed to identify the best block overlap size and smoothing parameter $\sigma$, which determines the kernel size (the kernel size was always taken as $4\sigma$ to maintain more than 95% of the ideal Gaussian filter). The optimal $\sigma$ of course depends on the noise level and on the images themselves; in our case, we conclude that $\sigma =1$ is the best choice, providing the highest recognition performance (see Table 1). As for the block overlap, it can be observed that while the differences are slight, the overlap (4,4) mostly yields the best results.

The effect of the smoothing kernel on the recognition rate can be shown through the following experiment. An image was selected from the ORL dataset and two Gassuain noise levels were applied to the image with standard deviations of 0.01 and 0.05. The noisy image was processed using the smoothing kernel with different kernel sizes and different smoothing parameters using SKTP. Then, the PSNR between the original image and the resulted image was measured. The results are shown in Figure 4. It is clear that a kernel size of 5 and smoothing value of 1.0 is the best choice for both noise densities.

A comparison with existing algorithms which do not utilize block processing is shown in Figure 5. The results with the proposed algorithm show higher accuracy than the existing algorithms presented in [11,55] in the presence of noise. Measured by average accuracy, the proposed algorithm shows an improvement of 1.29% and 8.44% compared to [11,55], respectively.

In order to show the promising performance of the proposed algorithm, a comparison was made with traditional methods in terms of computational cost as well. The experiment was performed for ten runs; the average computation time for each image is reported in

Table 3. ORL time (milliseconds) with different parameters for the proposed and traditional algorithms.

Kernel Size	Overlap Size	Traditional Algorithm	Proposed Algorithm	Speedup Ratio
3	0	9.461	1.172	8.07
3	2	14.385	1.198	12.01
3	4	29.601	1.212	24.42
5	0	10.207	1.168	8.74
5	2	15.590	1.172	13.30
5	4	31.965	1.193	26.79
7	0	12.974	1.177	11.02
7	2	19.855	1.185	16.75
7	4	41.193	1.214	33.93

. The experiment was performed with a block size of 20, smoothing kernel sizes of 3, 5, and 7, and overlap sizes of (0,0), (2,2), and (4,4). It can be observed that the computation time using the proposed algorithm is less than that of the traditional methods, and the improvement ratio increases as the overlap size increases. This is obviously because the proposed algorithm performs the computation for the entire image only once, while the traditional methods repeat the computation in a loop over all blocks.

Finally, a comparison was performed between the proposed algorithm and existing algorithms in terms of recognition accuracy; the results are listed in

Table 4. Comparison with existing algorithms for ORL Database.

Algorithm	Reference	Accuracy %
DWT–PCA	[76]	96.75
DCT–PCA	[77]	96.00
OLPP	[78]	93.50
Wavelet + PCA	[79]	94.20
Wavelet + LDA	[79]	97.10
GELM	[80]	96.30
NPE	[81]	94.33
ENPE	[81]	95.78
TSLDA	[82]	93.75
Improved TSLDA	[82]	94.58
DIWT-LBP	[51]	97.00
MLDV	[83]	85.36
RLD	[42]	97.49
DLCDRC	[84]	96.39
DLGWT	[7]	96.00
RMDL	[85]	95.00
Proposed Algorithm (smoothing kernel size = 5, overlap size = (4,4))		98.23

. It can be clearly observed that the proposed algorithm outperforms the existing algorithms in terms of recognition accuracy.

The second dataset is the FEI dataset [74] which is a Brazilian facial dataset. The FEI dataset is composed of 100 faces, including males and females. In the experiment we included ten images for each person, with a size of $640\times 480$. The participants’ images have a neutral background, their age is between 19 and 40 years, and the dataset consists of faces with facial expressions and poses of various types. Figure 6 shows samples of the FEI face dataset.

The experiment wass performed for three different image sizes: the original size ($480\times 640$ pixels), downsampled by a factor of two, and downsampled by a factor of four. Various block overlaps were tested. The accuracy is reported both for noise-free and noisy environments. The noise was Gaussian with two variance values and Salt and Pepper with two density values as depicted in Figure 7. The obtained results are reported in

Table 5. The reported face recognition accuracy (%) for the FEI dataset using the proposed algorithm.

Image Size	Block Size	Environment	Overlap Size
$480\times 640$	$48\times 48$		(0,0)	(2,2)	(4,4)	(8,8)	(12,12)
		Noise-free	95.50	97.00	96.75	97.50	96.50
		Gaussian 0.01	94.50	95.50	95.50	95.75	95.25
		Gaussian 0.05	94.00	95.00	95.00	96.00	95.50
		Salt&Pepper 0.05	95.50	96.75	97.00	97.00	96.25
		Salt&Pepper 0.10	95.25	95.50	96.50	96.75	96.75
Average			94.64	95.89	96.11	96.46	96.04
$240\times 320$	$24\times 24$		(0,0)	(2,2)	(4,4)	(6,6)	(8,8)
		Noise-free	95.50	96.50	97.50	96.50	96.75
		Gaussian 0.01	94.50	95.50	95.75	95.25	95.25
		Gaussian 0.05	94.00	94.50	95.75	95.25	95.25
		Salt&Pepper 0.05	95.50	96.50	97.50	96.50	97.00
		Salt&Pepper 0.10	95.25	96.50	97.25	96.75	96.50
Average			94.64	95.82	96.61	96.00	95.93
$120\times 160$	$12\times 12$		(0,0)	(1,1)	(2,2)	(3,3)	(4,4)
		Noise-free	95.75	96.25	97.25	96.50	96.50
		Gaussian 0.01	95.00	94.50	95.25	95.50	94.50
		Gaussian 0.05	93.75	95.00	95.00	94.50	94.50
		Salt&Pepper 0.05	95.50	96.25	97.00	96.00	96.50
		Salt&Pepper 0.10	94.25	95.75	96.50	96.00	96.50
Average			94.54	95.29	96.00	95.54	95.64

. The results show that the best overlap size for this dataset is one sixth of the block size. For example, with a block size of $48\times 48$, the best overlap size is (8,8), for a block size of $24\times 24$, the best overlap size is (4,4), and for a block size of $12\times 12$, the best overlap size is (2,2). As these results were obtained from a large image database, it is highly probable that these conclusions are valid for other datasets of a similar kind.

In order to illustrate the efficiency of our fast block processing method, the proposed algorithm was compared to an algorithm that processes the blocks sequentially. The experiment was performed with an image size of $480\times 640$, a block size of $48\times 48$, and for different overlap sizes, as shown in

Table 6. FEI time (milliseconds) of different methods.

Overlap Size	Traditional	Proposed	Improvement
(0,0)	55.278	1.806	30.60
(2,2)	65.585	1.967	33.35
(4,4)	76.684	2.055	37.31
(8,8)	115.391	2.293	50.32
(16,16)	447.883	4.915	91.12

, where the runtime in seconds is provided. The results show that the proposed algorithm outperforms the traditional one for all overlap sizes (obviously, larger overlap sizes lead to a higher improvement). The average incease in speed is about 50 times, which is quite impressive.

Finally, we compared the proposed algorithm to eleven state-of-the-art face recognition algorithms. The recognition rates are shown in

Table 7. Comparison with existing algorithms on FEI Database.

Algorithm	Reference	Accuracy %
LFLM–SIFT	[86]	85.3
PCNC	[87]	94.17
NFLS-II	[88]	93
DWT–PCA	[76]	96.25
DCT–PCA	[77]	95.85
DIWT-LBP	[51]	91.14
LDF	[89]	88.2
SESRCLDF	[89]	89
SESRC	[89]	83.98
RLD	[42]	93.57
PTGSP-CWP	[90]	93.3
DL-MFR	[91]	90.11
DL-RTHF	[92]	94.00
Proposed Algorithm		97.5

. It can be observed that, at least on this database, the proposed algorithm outperforms all compared algorithms.

5. Conclusions

In this paper, we have proposed a new face recognition method. It belongs to the category of “handcrafted” features-based techniques. Unlike deep learning methods, it does not require any time-consuming massive training on augmented datasets. The method is a cascade of several steps. The image is partitioned into overlapping blocks, which makes the method robust to local changes. Each block is described by orthogonal moments with respect to a carefully chosen polynomial basis. A noise-suppression filter is embedded into moment calculation with almost no overheads. This makes the method particularly efficient in recognition of noisy faces. High computational efficiency is ensured by an original fast block processing method that avoids treatment of blocks in slow loops. All these ideas together, when implemented into a single framework, result in a fast, robust, and reliable face recognition method, as demonstrated in this paper by numerous experiments. To increase the recognition accuracy, future research could further examine noisy environments using a non-local mean filter as an alternative to the embedded Gaussian filter.