Copy-Move Forgery Detection Using Scale Invariant Feature and Reduced Local Binary Pattern Histogram

Abstract

Because digitized images are easily replicated or manipulated, copy-move forgery techniques are rendered possible with minimal expertise. Furthermore, it is difficult to verify the authenticity of images. Therefore, numerous efforts have been made to detect copy-move forgeries. In this paper, we present an improved region duplication detection algorithm based on the keypoints. The proposed algorithm utilizes the scale invariant feature transform (SIFT) and the reduced local binary pattern (LBP) histogram. The LBP values with 256 levels are obtained from the local window centered at the keypoint, which are then reduced to 10 levels. For a keypoint, a 138-dimensional is generated to detect copy-move forgery. We test the proposed algorithm on various image datasets and compare the detection accuracy with those of existing methods. The experimental results demonstrate that the performance of the proposed scheme is superior to that of other tested copy-move forgery detection methods. Furthermore, the proposed method exhibits a uniform detection performance for various types of test datasets.

1. Introduction

Copy-move forgery (CMF) is a popular image tampering method, wherein a portion of an image is copied from one section of the image and is pasted elsewhere in the same image. An image can be forged to conceal or change its meaning by the copy-move process. Therefore, it is important to verify the authenticity of the image and localize the copied and moved regions. Because the copied portion of an image is generally scaled or rotated, it is difficult to verify the authenticity of the image based on visual inspection alone. For this reason, the development of reliable copy-move forgery detection (CMFD) methods has become an important issue [1,2,3]. The common framework of CMFD comprises five steps: preprocessing (optional), feature extraction, matching, false match removal, and localization.

The optional first step of the CMFD process is preprocessing. In this step, the conversion of RGB color channels to grayscale [4,5] is often exploited to reduce the dimensionality of the input images. Alternately, RGB colors can be converted into the YCbCr [6,7] or the HSV [8] color space to use both the luminance and chrominance information. Various block division and segmentation methods can be considered for use in preprocessing. An image can be divided into overlapping square blocks [9,10,11], non-overlapping square blocks [12], or circular blocks [13,14]. Image segmentation techniques [15,16] are often included in the preprocessing step to separate the copied source region from the pasted target region.

Among these five CMFD steps, feature extraction is the main step of the CMFD process. Extracted features must be invariant to scale and rotation, and must be robust when subjected to post-processing steps, such as blurring, compression, and noise addition. Transform-based methods are frequently exploited to eliminate information that is unnecessary for detection, in addition, to enhancing the essential components. A variety of transform methods, such as the polar cosine transform [17], Fourier–Mellin transform [18,19], and polar complex exponential transform [20] were used for forgery detection, in conjunction with the popular Fourier transform [5], discrete cosine transform [7,11,21,22,23], and various wavelet transforms [7,11,24,25,26]. Recently, the local binary pattern (LBP) was successfully exploited to detect CMFs in combination with the wavelet transform [25] and singular value decomposition [27]. The center symmetric local binary pattern (CSLBP) [28], which is a variant of the LBP, was used to make CMFD more robust against noise during feature extractions. As another class of methods used to detect CMF, keypoint-based approaches have been actively studied thus far. Because keypoint features are robust under scaling, rotation, and occlusion, they are well suited to the CMFD process. Since the time that scale invariant feature transform (SIFT) was applied to forgery detection [29], various SIFT-based transforms, such as, binarized SIFT [30], opponent SIFT [31], and affine SIFT [32], have been applied to the CMFD. In addition to these schemes, histogram-based techniques [4] and statistical moment-based methods [20,33,34] have also been presented. Please refer to the referenced papers [1,2,3] for more details on these algorithms and other feature extraction methods.

Feature matching is a process of determining a candidate pair of the original section and the corresponding copy-move section using the extracted features. This process utilizes searching and similarity measurement techniques. Searching methods contain various sorting [6,7,35], nearest neighbor [31,36], and hashing methods [16]. These algorithms usually involve the use of dimension reduction techniques. During the searching process, the matching methods search for possible matches to evaluate the similarity between the selected possible matches. The Euclidean distance is the most popular and simple similarity metric employed. Several CMFD methods [4,16,20,35] use Euclidean distance. Additionally, Manhattan distance [37] and Hamming distance [30] between two features have also been employed to determine similarity.

However, even after the completion of the feature matching process, the false positive matches are not completely eliminated. To eliminate these false matches, various clustering algorithms, such as J-linkage clustering [31], distance-based clustering [38], and hierarchical clustering [39,40] have been presented to separate the authentic and tampered areas. One of the most robust and frequently used false match removal methods is the random sample consensus (RANSAC) algorithm, which can remove outliers from the matched features. The RANSAC algorithm is widely used in keypoint-based CMFD methods [15,31,35,36,39,40,41].

The final step in the CMFD process is the localization process. The detection output can be visualized as a binary image that presents the detected copy-moved regions and their corresponding authentic image parts within the target image. This process is commonly applied with various post-processing methods.

Keypoint-based CMFD algorithms have attracted a significant amount of attention in recent years. SIFT is one of the most frequently used keypoint extraction methods for the detection of CMF. SIFT generates both scale- and rotation-invariant keypoints, and each keypoint is commonly represented by a 128-dimensional descriptor. The SIFT descriptor of a keypoint is obtained from 16 4 × 4 windows around the keypoint and is generated as a set of gradient histograms representing 8 directions. However, although keypoint-based methods have been successfully applied to CMFD, their performance is degraded when the CMF implementation involves small or smooth regions [31,42]. Additionally, when a keypoint exists close to the boundary of the copy-moved portion and the authentic region or if an image has been compressed after CMF, the keypoint descriptor of the copied portion will be different from that of the moved portion.

For a single keypoint, the existing SIFT-based methods divide a 16 × 16 window into 16 sub-windows, each of size 4 × 4 pixels. The gradient values for the corresponding 8 directions in a 4 × 4 sub-window are used to generate an 8-dimensional descriptor for each sub-window. Next, the descriptors in all 16 sub-windows are arranged in series to create the final 128-dimensional descriptor. The limitation of the conventional descriptor generation method is that it only provides local information about a single keypoint. Because this method cannot represent global information around the keypoint, it may be difficult to cope with pixel changes, such as compression or differences in the background area caused by the copy-move process.

In this paper, we present an improved CMFD algorithm by adding a new descriptor. The proposed additional descriptor based on the LBP feature is capable of capturing global information associated with the keypoints. LBP is acknowledged as one of the features that is sufficiently robust to handle small pixel changes. For this reason, the proposed descriptor is generated using a histogram of LBP values for a 16 × 16 window centered on the keypoint. The LBP values are not generated at every pixel in the image but only for keypoints by the SIFT. Because a typical LBP has 256 levels for a pixel, we reduce the LBP levels to 10 to prevent an increase in the descriptor dimension. In total, the proposed descriptor for a keypoint has 138 dimensions. By means of experiments using various test datasets, we demonstrate that the proposed method generates more accurate estimation results in detecting CMFs than conventional methods.

The remainder of this paper is organized as follows. Section 2 introduces the basic process of the SIFT-based CMFD method and its limitations. Section 3 presents the proposed CMFD algorithm. In Section 4, the performance of the proposed method is compared with those of existing methods using the experimental results. Section 5 presents the discussion, and the conclusion is presented in Section 6.

2. SIFT-Based Copy-Move Forgery Detection

2.1. SIFT Descriptor

Figure 1 illustrates the basic workflow for the SIFT-based CMFD. For a given image I, SIFT features are extracted at different scales using a scale-space representation by an image pyramid. Potential keypoints are selected using scale-space extrema. All the potential keypoints are further refined according to a contrast and an edge threshold. This process is used to eliminate unstable keypoints in the SIFT algorithm. In the next step, an orientation is assigned to each keypoint to achieve invariance to image rotation. The gradient magnitude and direction are calculated in a local window centered at the SIFT keypoint. An orientation histogram with 36 bins covering 360 degrees is created. The highest peak in the histogram is considered as the dominant orientation. Furthermore, any peak above 80% of the highest peak is also considered while calculating the main orientation.

To generate a 128-dimensional descriptor for a keypoint, a 16 × 16 local window centered at the keypoint is considered. This window is divided into 16 sub-blocks each of size 4 × 4 pixels. For each sub-block, an 8-bin orientation histogram is created. A total of 128-bin values are obtained, and they are represented as a vector to form the keypoint descriptor. Let {k₁, k₂, …, k_m} be the m-keypoints extracted using the SIFT for the given image, I. Keypoint descriptors {f₁, f₂, …, f_m} corresponding to {k₁, k₂, …, k_m} are generated using the above procedures. Figure 2 shows the generation method of a descriptor f_i for a keypoint k_i at the image location (x_i,y_i). As shown in Figure 2, the SIFT descriptor is represented as a list of gradients for the main direction in 16 4 × 4 sub-blocks around the keypoint. However, simply listing local gradients in this manner can tend to degrade the matching performance as the pixel values around the keypoints change.

2.2. Matching

If a pixel of an image is copied and moved, the keypoint descriptor of that pixel location, f_i needs to be compared with all the other descriptors other than f_i represented as f_j≠i. This process is called matching. Let {d_1,i, d_2,i, …, d_m−1,i} be the set of distances from f_i and m−1 descriptors other than f_i. At this point, each distance has the following relationship,

$$d_{1,i}\le d_{2,i}\le \cdots \le d_{m-1,i}.$$

(1)

The keypoint f_i is determined to be matched with the key point at distance d_1,i if the following relation is satisfied, that is

$$\frac{d_{1,i}}{d_{2,i}}<t,$$

(2)

where t is the threshold defined as t ∈ (1,0). In this paper, t is set to 0.65.

However, a false matching almost always exists after the completion of the matching process. Therefore, a range of methods has been studied with the aim of eliminating false matching. Mismatched keypoint pairs have been eliminated using various clustering algorithms, such as J-linage clustering [31], distance-based clustering [38], and hierarchical clustering [39,40]. In particular, the RANSAC algorithm is the most frequently used to eliminate false matches [15,31,35,36,39,40,41]. However, these algorithms can only eliminate the false matches but cannot generate the correct matched keypoint pairs.

Figure 3 illustrates an example of a false match based on the conventional SIFT descriptor [36], wherein a keypoint exists close to the boundary of the copy-moved portion and the authentic region. In Figure 3, a keypoint k_A has been moved to k_B. For a correct match, k_A and k_B should be matched by Equation (2). However, the keypoint k_B is detected as the potentially matched keypoint with k_A because k_B has the closest distance (d_1,A = 0.2684) to k_A. In contrast, the distance between k_A and k_C is calculated as d_2,A = 0.2721, and no matching occurs because d_1,A/d_2,A exceeds the threshold t. This is because the background (16 × 16 window centered at k_A) of k_A is different from that of k_B. This situation may also occur if the image is compressed after CMF.

3. Proposed Method

In this paper, we propose an improved CMFD method by adding an LBP histogram-based descriptor. The LBP value is obtained for every pixel in the 16 × 16 window centered on the keypoint. The 256 LBP levels are reduced to 10 levels, and their histogram is used as a new descriptor. The main contribution of the proposed method is that the histogram of the reduced LBP values corresponding to a keypoint is used as an additional descriptor to increase the matched keypoint pairs.

3.1. Reduced LBP Feature

The LBP is one of the general features used to extract the texture information of an image. Owing to its discriminative performance and computational simplicity, the LBP feature is widely used in various applications. For a pixel in an image located at (p,q), the LBP value is calculated as follows.

$$L(p,q)={\displaystyle \sum _{n=0}^{N-1}s\left(I_n-I(p,q)\right)2^n},$$

(3)

where L(p,q) is the LBP value of the center pixel located at (p,q), I_n is the intensity of the neighboring pixel, I(p,q) is the intensity of the pixel at (p,q), and N is the number of neighboring pixels chosen at a given radius. In this paper, we use N = 8 (3 × 3 local window centered at (p,q)), which generates am 8-bit LBP value. In Equation (3), s(x) is defined as

$$s(x)=\{\begin{array}{cc}1,& \mathrm{if}x\ge 0\\ 0,& \mathrm{otherwise}\end{array}.$$

(4)

Let Ω(x_i,y_i) be the set of pixels that exist in a 16 × 16 local window centered at the keypoint k_i location, (x_i,y_i). Using all the pixels at (p,q) ∈ Ω(x_i,y_i), LBP values are calculated as depicted in Figure 4.

The SIFT feature already contains a considerable amount of information for detecting CMFs. Therefore, it is not necessary to use all the LBP information. An LBP can be classified into two categories. If the binary pattern contains at most two 0→1 or 1→0 transitions, it is called a uniform pattern. For example, 00110000 (2 transitions) is a uniform pattern, but 01010100 (6 transitions) is a non-uniform pattern. Among the 256 LBP values, 58 LBP values are uniform, and the rest are non-uniform. A uniform pattern is characterized by a series of consecutive 1’s. Let L_c(p,q) (c = 0, 1, 2, …, 8) be the LBP with c consecutive 1’s. Obviously, L₀(p,q) = 00000000, and L₈(p,q) = 11111111. For c = 1, 2, …, 7, L_c(p,q) has 8 binary patterns that can be all be viewed as rotationally shifted versions of a single pattern. Figure 5 shows various uniform patterns. Let L_non(p,q) be any pattern that has no consecutive 1’s except for L₀(p,q). In conclusion, the 256-level LBP values can be divided into 10 groups, that is, nine types of L_c(p,q) and one L_non(p,q).

3.2. Proposed Descriptor

In this paper, we use the probabilities of L_c(p,q) and L_non(p,q) as a new descriptor for CMFD. To maintain the rotation-invariant characteristic of the new descriptor, we check the occurrence of L_c(p,q) alone. L_non(p,q) can reflect a frequent variation in a small window, which may occur because of noise, quantization errors, or small background changes. To reduce the effect of these variations, all non-uniform patterns are checked as they occur. The proposed descriptor r_i corresponding to keypoint k_i is obtained as

$$r_i=\left\{R_0(x_i,y_i),\cdots ,R_8(x_i,y_i),R_{non}(x_i,y_i)\right\},$$

(5)

where R_c(x_i,y_i) and R_non(x_i,y_i) are the normalized number of occurrences of L_c(p,q) and L_non(p,q), respectively, in Ω(x_i,y_i). R_c(x_i,y_i) is calculated by

$$R_c(x_i,y_i)=\frac{\#\left[L_c(p,q)\right]}{\left|\mathsf{\Omega }(x_i,y_i)\right|},\mathrm{for}\mathrm{all}(p,q)\in \mathsf{\Omega }(x_i,y_i),$$

(6)

where #[L_c(p,q)] is the number of occurrences of the L_c(p,q) pattern in Ω(x_i,y_i), and |Ω(x_i,y_i)| is the cardinality of Ω(x_i,y_i). R_non(x_i,y_i) can be obtained in a similar manner. r_i is composed of the histogram of L_c(p,q) and L_non(p,q). It is a 10 dimensional feature vector. Figure 6 illustrates the r_i generation method using the reduced LBP histogram.

The proposed descriptor for a keypoint, based on SIFT and the histogram of the reduced LBP, is obtained as

$$g_i=\left\{f_i,r_i\right\},$$

(7)

where g_i is the proposed descriptor for CMFD and has 138 dimensional features. Because the descriptor, r_i is generated for a relatively large area, unlike f_i, it may be sufficiently robust to handle small pixel changes and quantization errors caused by image compression.

In Figure 4, we investigated a no-match case using the conventional SIFT descriptor. We apply the proposed descriptor to this case, and Figure 7 depicts the result of this case. As shown in Figure 7, we observe that the failed match is transformed into a successful match by using the proposed descriptor. The keypoint, k_B is detected as the potentially matched keypoint with k_A because k_B has the closest distance (d_1,A = 0.1426) to k_A. The distance between k_A and k_C is calculated as d_2,A = 0.2380. Because d_1,A/d_2,A does not exceed the threshold t, we can determine that k_A and k_B are the matched pair. Based on this result, we conclude that the proposed LBP-based descriptor plays an important role in removing the effect of a small fluctuation that occurred because there was a keypoint close to the boundary of the copy-moved portion and the authentic region.

3.3. Estimation of Affine Transform and False Match Removal

For the putative matched keypoint pairs, the geometric distortions, such as the rotation, scaling, and shearing of the duplicated regions can be estimated. Let (x_i,y_i) and (x’_i,y’_i) be the pixel locations from a region and its duplicate, respectively. These two locations are related by an affine transform as follows.

$$\left(\begin{array}{c}{x}_i^{\prime }\\ y_i^{\prime }\end{array}\right)=\left(\begin{array}{cc}{t}_{11}& t_{12}\\ t_{21}& t_{22}\end{array}\right)\left(\begin{array}{c}{x}_i\\ y_i\end{array}\right)+\left(\begin{array}{c}{x}_0\\ y_0\end{array}\right),$$

(8)

where t₁₁, t₁₂, t₂₁, t₂₂, x₀, and y₀ are the transform parameters. To estimate these parameters, at least three pairs of corresponding keypoints that are not collinear are required. However, the obtained parameters of the affine transform are inaccurate because of the mismatched keypoints. To eliminate unreliable keypoint matches, the widely used RANSAC scheme is employed. The parameters can be obtained using the RANSAC algorithm exhibit a high degree of accuracy. Furthermore, the affine transform parameters can also be used to determine the correlation map of the duplicated region.

After executing the RANSAC algorithm, the degree of rotation and scaling are estimated using the conventional SIFT and the proposed method.

Table 1. Affine parameter estimation results using the conventional SIFT algorithm [36] and the proposed methods for the MICC-F220 dataset. The averaged rotation angles and scales for various attacks are presented in this table.

Attack: (Θ°, sx, sy) 1	Conventional SIFT [36]	Proposed Method
0°, 1.0, 1.0	1.364°, 1.042, 0.974	0.252°, 1.007, 0.997
10°, 1.0, 1.0	9.186°, 1.051, 0.973	9.975°, 1.024, 0.974
20°, 1.0, 1.0	19.494°, 1.501, 0.941	19.756°, 1.013, 0.991
30°, 1.0, 1.0	30.581°, 1.228, 0.894	30.183°, 1.012, 0.992
40°, 1.0, 1.0	39.682°, 1.043, 0.960	39.906°, 1.013, 0.990
0°, 1.2, 1.2	1.004°, 1.190, 1.128	0.179°, 1.145, 1.031
0°, 1.3, 1.3	0.792°, 1.415, 1.278	0.183°, 1.264, 1.252
0°, 1.4, 1.2	0.525°, 1.327, 1.124	0.236°, 1.358, 1.154
10°, 1.2, 1.2	9.580°, 1.245, 1.143	10.280°, 1.146, 1.127
20°, 1.4, 1.2	21.038°, 1.317, 0.992	19.816°, 1.359, 1.167

¹Θ° is a rotation angle, s_x and s_y are the scaling parameter for x and y coordinates, respectively.

presents the estimation results of the 10 different combinations of geometric transforms applied to the MICC-F220 dataset [36]. The MICC-F220 dataset comprises 110 tempered images and their corresponding 110 originals. The image resolution varies from 722 × 480 to 800 × 600 pixels, and the size of the forged portion covers, on average, 1.2% of the entire image. As shown in Table 1, the transform parameters using the proposed method are more accurate than those of the conventional SIFT algorithm. Thus, we conclude that the proposed descriptor based on the histogram of the reduced LBP plays a positive role in the detection of CMF.

3.4. Localization

To localize the duplicated regions affected by CMF, the correlation map between the original image and the warped image is frequently used. Let W be the warped image obtained by transforming the image according to the affine transform. The correlation coefficient at a pixel location (x,y), ρ(x,y) is computed as

$$\rho (x,y)=\frac{{\displaystyle \sum _{(u,v)\in \mathsf{\Lambda }(x,y)}\left(I(u,v)-I_{\mu }\right)\left(W(u,v)-W_{\mu }\right)}}{{\displaystyle \sum _{(u,v)\in \mathsf{\Lambda }(x,y)}{\left(I(u,v)-I_{\mu }\right)}^2{\left(W(u,v)-W_{\mu }\right)}^2}},$$

(9)

where Λ(x,y) is a 5 × 5 local window centered at (x,y), and I_μ and W_μ are the average values of I and W in the area Λ(x,y). A Gaussian filter is applied to the correlation map to reduce the noisy pixels, and a binary correlation map is obtained by a threshold. If the ρ(x,y) value for point (x,y) is greater than a threshold, this point is considered to be true, otherwise, this point is assigned a value of false.

3.5. Summary of Proposed Method

The overall algorithm of the proposed CMFD method is presented in Figure 8. SIFT is performed on the image suspected to have undergone CMF, to extract keypoints. For a keypoint k_i at the image location (x_i,y_i), the conventional 128-dimensional descriptor f_i is generated. For all the pixels in a 16 × 16 window centered at that keypoint location, pixel-wise LBP values are calculated. Next, the 256-level LBP values are reduced to 10 types of values. A histogram of the reduced LBP values is generated, and we let this 10-dimensional histogram be the additional descriptor r_i. Next, g_i, which is the combination of f_i and r_i, becomes the new descriptor for CMFD. For the final output, the false matching removal step, followed by localization using the RANSAC algorithm is performed.

4. Experimental Results

To evaluate the performance of the proposed method, we first define three measures at the image level and pixel level. At the image level, the ability to correctly verify whether an images forged or not is measured, and the forgery localization accuracy performance is analyzed at the pixel level. In this paper, we use three measures, namely, true positive rate (TPR), false positive rate (FPR), and accuracy (ACC). TPR is used to measure the percentage of actual positives that are correctly identified, and it is defined as

$$TPR=\frac{\#\mathrm{images}\left(\mathrm{pixels}\right)\mathrm{detected}\mathrm{as}\mathrm{forged}\mathrm{being}\mathrm{forged}}{\#\mathrm{genuine}\mathrm{images}\left(\mathrm{pixels}\right)}.$$

(10)

FPR is the fraction of original images (pixels) that are not correctly identified, and it is obtained as

$$FPR=\frac{\#\mathrm{images}\left(\mathrm{pixels}\right)\mathrm{detected}\mathrm{as}\mathrm{forged}\mathrm{being}\mathrm{genuine}}{\#\mathrm{genuine}\mathrm{images}\left(\mathrm{pixels}\right)}.$$

(11)

A well-designed CMF detector must simultaneously maintain a high TPR and low FPR. ACC is the percentage of correct decisions and is defined as

$$ACC=\frac{\#\mathrm{corrected}\mathrm{detected}\mathrm{images}\left(\mathrm{pixels}\right)}{\#\mathrm{total}\mathrm{mages}\left(\mathrm{pixels}\right)}.$$

(12)

4.1. Dataset

In our simulation, we use four test datasets, namely, MICC-F220 [36], CMH [8], D [43], and COVERAGE [44]. The detailed information regarding these four datasets is summarized in

Table 2. Detailed information of five datasets.

Dataset	Description
MICC-F2200	110 tampered images and 110 untampered images with resolutions ranging from 722 × 480 to 800 × 600
CMH	216 forged images with resolutions varying from 845 × 634 to 1296 × 972 (108 uncompressed and 108 compressed images)
D	970 tampered images and 50 authentic images with resolutions of 700 × 1000 (D0, D1, D2: tampered, D3: authentic)
COVERAGE	100 tampered images and 100 authentic images with resolutions of 400 × 486

. In this paper, we use the TPR and FPR values presented in the published papers for each test dataset.

4.2. Detection Results on Various Datasets

4.2.1. Results Obtained on MICC-F220 Dataset

Table 3. True positive rate (TPR) (%), false positive rate (FPR) (%), and accuracy (%) on the MICC-F220 dataset at an image level. The number in bold indicates the highest performance, and the number in italics represents the second place.

Method	TPR	FPR	ACC
DAISY [45]	85.91	9.09	88.41
LSIF [46]	83.64	5.45	89.09
Clustering [47]	97.87	7.63	95.12
DF [48]	84.55	17.27	75.36
MRF [49]	62.00	40.00	61.00
ICMFD [35]	78.18	48.18	69.08
GDCMFD [8]	64.00	57.00	53.50
HFPM [42]	100	1.82	99.09
Proposed	99.10	5.45	96.82

presents the detection performance using the MICC-F220 dataset. Because this dataset has no ground truth, three performance measures are obtained by at the image level. The performance of the proposed method is compared with that of various state-of-the-art CMFD methods, such as, improved DAISY descriptor (DAISY) [45], local invariant symmetry features (LISF) [46], 2-levels clustering strategy (Clustering) [47], dense filed-based method (DF) [48], Markov random field-based method (MRF) [49], iterative copy-move forgery detection (ICMFD) [35], going deeper into copy-move forgery detection (GDCMFD) [8], and hierarchical feature point matching-based method (HFPM) [42]. As presented in Table 3, HFPM exhibits the highest ACC of 99.10. The proposed CMFD algorithm achieves the second rank with an ACC of 96.82. For the MICC-F220 dataset, keypoint-based methods [42,47], including the proposed algorithm, demonstrate relatively better performance than block-based approaches.

4.2.2. Results Obtained on CMH Dataset

The CMH dataset has four types of uncompressed 108 realistic cloning images maliciously tampered with in various ways (23 plain copy-moved images (CMH₁), 25 rotated images (CMH₂), 25 resized images (CMH₃), and 35 images that are both rotated and resized (CMH₄)). Additionally, to address compressions, we compressed the full image into a JPEG format using quality factors of 70%, 80%, and 90% (CMH₅).

Table 4. TPR (%), FPR (%), and ACC (%) on the uncompressed CMH (CMH1, CMH2, CMH3, and CMH4) datasets at the pixel level. Bold numbers indicate the highest performance, and italic numbers represent the second place.

Method	TPR	FPR	ACC
LSIF [46]	80.68	0.28	90.02
SIFT [36]	50.45	0.19	75.13
HT [50]	91.71	1.98	94.86
SIFTJL [31]	81.96	4	88.98
ZM [34]	34.43	5.35	64.47
GDCMFD [8]	71.23	1.54	84.84
AO [51]	81.18	3.23	88.97
SCMFD [15]	73.11	48.74	62.18
Proposed	95.68	0.35	97.66

presents the detection performance on this dataset. Every image has its own ground truth indicating the original and cloned regions in white color. For comparison, LSIF [46], SIFT-based forensic method (SIFT) [36], Helmert transform-based method (HT) [50], SIFT and J-linkage-based method (SIFTJL) [31], Zernike moment-based method (ZM) [34], GDCMFD [8], adaptive over-segmentation-based method (AO) [51], and segmentation-based CMFD (SCMFD) [15] are used.

Table 4 presents the detection performance on the uncompressed CMH dataset (CMH₁, CMH₂, CMH₃, and CMH₄) at the pixel level. As shown in Table 4, all the CMFD methods except SCMFD exhibit good FPR values. However, only LSIT, HT, AO, and the proposed method exhibit valid TPR values. The proposed algorithm achieves the highest ACC, and HT exhibits the second highest performance.

Most CMFD approaches tend to degrade in their detection performance when operating on a compressed image. However, our method is considerably robust in handling compressed images during detection. To evaluate the CMFD performance for various forgery detection algorithms, three performance measures are tested on the CMH₅ test dataset.

Table 5. TPR (%), FPR (%), and ACC (%) on the compressed CMH5 dataset at the pixel level. Bold numbers indicate the highest performance, and italic numbers represent the second place.

Method	TPR	FPR	ACC
LSIF [46]	79.38	0.52	89.43
SIFT [36]	48.29	0.2	74.04
HT [50]	68.51	1.22	83.64
SIFTJL [31]	45.59	3.65	70.97
ZM [34]	28.6	0.23	63.72
GDCMFD [8]	31.19	0.65	65.27
AO [51]	45.76	2	71.88
SCMFD [15]	31.36	48.8	41.27
Proposed	95.8	0.36	97.72

shows the detection performance on uncompressed CMH₅ dataset at the pixel level. As shown in Table 5, the performance of many CMFD approaches, except those of LSIF, SIFT, and the proposed method, is degraded. In particular, the performance degradation of the block-based algorithms, such as HT, ZM, and GDCMFD, is considerable. The TPR, FPR, and ACC values of our methods are almost the same as those of the uncompressed CMH datasets. This advantage of the proposed CMFD method can be attributed to the addition of the reduced LBP descriptor.

Figure 9 depicts the CMF region localization examples for the CMH dataset. As depicted in Figure 9, the proposed method exhibits the best localization performance. HT also demonstrates good localization results. However, this method does not reveal the details of the copied and moved regions. SIFTJL and AO demonstrate limited localization performances, whereas GDCMFD, based on statistical moments, demonstrates extremely poor localization performance.

4.2.3. Results on Obtained D Dataset

The D dataset comprises medium sized images (almost all of which are 1000 × 700 or 700 × 1000) and is subdivided into four datasets (D₀, D₁, D₂, and D₃). The first dataset D₀ is made of 50 uncompressed images with simply translated copies. D₁ is created by copy-pasting objects after rotation, and D₂ is derived by of applying scaling to the copies. The subset D₃ comprises 50 original images without tampering. For comparison, HT [50], SIFTJL [31], GDCMFD [8], and AO [51] are used.

Table 6. TPR (%), FPR (%), and ACC (%) on D dataset at pixel level. Bold numbers indicate the highest performance, and italic numbers represent the second place.

Method	D0			D1 and D2			D3
	TPR	FPR	ACC	TRR	FPR	ACC	FPR
HT [50]	84.88	3.39	90.75	85.64	1.06	92.29	0.05
SIFTJL [31]	73.41	2.42	85.5	71.39	0.47	84.96	0.12
GDCMFD [8]	64.14	1.89	81.13	46.39	0.62	72.89	0.39
AO [51]	62.08	1.72	80.18	46.39	0.49	72.95	2.34
SCMFD [15]	77.09	49.42	63.84	25.45	52.24	36.61	48.97
Proposed	97.65	1.25	98.2	92.31	0.65	95.83	0

presents the detection performances on the D dataset. The proposed CMFD approach achieves the best detection performance, and HT achieves the second place with respect to ACC for the D₀, D₁, and D₂ datasets. Because the D₃ dataset contains only authentic images, only FPRs are compared in Table 6. The proposed method does not find any image to be manipulated as a copy-move image, and has an FPR value of zero. Figure 10 illustrates forged localization examples for the D dataset. As shown in Figure 10, the proposed CMFD algorithm exhibits the best localization performance.

4.2.4. Results Obtained on COVERAGE Dataset

This dataset has 100 original and forged image pairs, with an average resolution of 400 × 486. For comparison, DF [46], SCMFD [15], ZM [34], GDCMFD [8], ICMFD [35], and HFPM [42] are used.

Table 7. TPR (%), FPR (%), and ACC (%) on the COVERAGE dataset at image level. Bold numbers indicate the highest performance, and italic numbers represent the second place.

Method	TPR	FPR	ACC
DF [46]	59.34	21.98	68.68
SCMFD [15]	87.91	63.74	62.09
ZM [34]	46.15	15.38	65.39
GDCMFD [8]	91.21	70.33	59.94
ICMFD [35]	76.92	71.43	52.75
HFPM [42]	80.22	41.76	69.23
Proposed	78	43	67.5

shows the image level detection performance on the COVERAGE dataset. Most algorithms perform poorly because each image contains similar-but-genuine objects in this dataset. HFPM exhibits the best ACC value, whereas the ACC of our method ranked third. However, the difference in the ACC between the method that achieved the first place, and the proposed method is only 1.73.

5. Discussion

In this paper, we compared the performance of our method with various CMFD methods for four datasets.

Table 8. ACC (%) ranking list on all test datasets.

Dataset		Rank
		1st	2nd	3rd
MICC-F220		HFPM	Proposed	Clustering
CMH	CHM1, 2, 3, 4	Proposed	HT	LISF
	CMH5	Proposed	LISF	HT
D	D0	Proposed	HT	SIFTJL
	D1,2	Proposed	HT	SIFTJL
	D3	Proposed	HT	SIFTJL
COVERAGE		GDCMFD	DF	Proposed

presents the ACC ranks of the CMFD methods for all the test datasets. For datasets, such as CMH and D, the proposed algorithm exhibited the highest CMFD performance. Our method achieved the second highest performance for the MIC-F220 dataset and ranked in the third place for the COVERAGE dataset. Overall, the proposed method demonstrated a high performance on average for various data. Many conventional CMFD methods exhibited performance variations depending on whether the image was compressed or not and the type of test dataset. For compressed image datasets, such as CMH₅, our approach exhibited almost the same detection accuracy as that for uncompressed image datasets. In particular, our algorithm also achieved the highest rank for the dataset wherein the image was geometrically transformed. HT also exhibited a fairy good ranking, but fell short of that of the proposed method. Based on the results of Table 8, we can conclude that the proposed method results in a more uniform and consistent CMFD detection performance, regardless of the type of dataset.

6. Conclusions

In this paper, we introduced a new CMFD algorithm by adding the reduced LBP histogram-based descriptor. 256-level LBP features were first generated for a 16 × 16 window centered at a single keypoint. Next, the 256-level LBP values were reduced to 10 values to prevent an increase in the descriptor dimension. The histogram of the reduced LBP features was used as the additional descriptor to detect the CMF. In total, the proposed descriptor for a keypoint had 138 dimensions. We evaluated four types of test datasets. Additionally, the performance of the proposed method was compared with that of the existing CMFD algorithms. The simulation results showed that the proposed CMFD scheme generated more accurate estimation results while detecting CMFs than those obtained from conventional methods. The proposed method also demonstrated a relatively uniform and consistent detection performance regardless of the different types of test datasets.