Detecting Generated Images by Fitting Natural Image Distributions

We are truly grateful for the reviewers' dedicated efforts. The valuable comments greatly improve the quality of our work. We provide the following answers to the reviewers' concerns.

Q1. Gap Between Motivation and Implementation, and differentiable issue.

Inresponse to your valuable comment, we have added the following details to our revision to highlight the derivation process of our method.

Our method is based on the proposed orthogonality principle, i.e., Eq. 6. Subsequently, we introduce Eq. 8 inspired by previous works for realization. Namely, the gradient of a neural network w.r.t. the input is orthogonal to the tangent space. According to the well-know property of transformation, we can realize f2 using a composite function, where the utilized transformation models the transformation along local data manifold. Thus, we derive the orthogonal property in Eq. 11.

Most transformations used in the literature can be differentiable by introducing the bilinear interpolation [1,2], usually implemented by the torch.nn.functional.grid_sample function.

Q2. Insufficient Validation of Flow-Based Extrusion (F-ConV)

Thank you for your kind suggestion. To provide a stronger comparison, we additionally trained a binary classifier on the DINOv2 embeddings using the same training set. As shown in the table below, the performance of the directly trained binary classifier falls short of that achieved by F-ConV, highlighting the advantage of our manifold-based approach.

Thanks again for the constructive comment. Accordingly, we have added the above results to our revision.

Q3. Thresholding Details: The threshold that determines whether an image is synthetic is a critical component of the proposed method. While briefly mentioned in Appendix (Page 14, Line 514), more detail/discussion is needed regarding how this threshold is chosen and whether it generalizes.

Thanks for pointing out this potentially confusing description issue. We have added the following explanations to our revision. To optimize overall accuracy, we can establish the classification threshold at a value that maximizes the distinction between natural and generated images. However, in real-world applications, this approach may differ.

For instance, to prioritize the detection of generated images, administrators may set a higher threshold, classifying only samples with similarity scores approaching 1 as natural images. This is consistent with the motivation of leveraging AUROC and AP as the main metric for evaluation.

Regarding the threshold of accuracy, we used the training set from GenImage to select a threshold and applied that threshold to all test sets. As shown in the table below, this approach resulted in a slight performance difference.

Q4. Performance Variability Across Generative Models: As shown in Tables 1 and 5, the proposed ConV/F-ConV do not consistently outperform all baselines. For images generated by models such as DiT, Stable Diffusion v1.4/1.5, and GLIDE, performance lags behind other methods by a notable margin. A deeper analysis of these failure cases could yield valuable insights into the limitations of the approach and its sensitivity to different generative model architectures or styles.

We speculate that this phenomenon can be intuitively explained using the FID (Fréchet Inception Distance) score. The FID score is a commonly used evaluation metric for generative models, primarily assessing the quality of the generative model by comparing the distribution differences between generated images and natural images in the feature space. A lower FID score indicates that the distribution of the generated images is closer to that of the natural images. As shown in the table below, we have listed the FID scores of several generative models, along with the detection performance of ConV on these models. It is clearly evident that as the FID score of the generative model increases, the detection performance of ConV improves. This is because ConV leverages the differences in data distribution between natural images and generated images for detection. When the differences in data distribution between generated images and natural images are small, directly using ConV may not yield satisfactory results. In such cases, we can employ the proposed F-ConV, which utilizes manifold learning to push generated images out of the natural distribution, thereby increasing the distribution differences between the two.

Q5. Regarding Figure 2: How are the embeddings generated; What do the “natural images” and “synthetic images” refer to in this visualization?

To visualize the feature distributions of natural and generated images, we use the DINOv2 model to extract their features/embeddings and apply t-SNE for dimensionality reduction. In the resulting visualization, red dots denote features of natural images, while purple dots represent those of generated images.

Q6. Can the proposed method be extended to detect AI-edited images (e.g., real images with minor synthetic modifications)?

Thanks for your inspiring question. We further evaluated the performance of ConV using tampered images from the SD_inpaint dataset. This dataset was constructed by first obscuring regions of natural images and subsequently restoring them using a DDPM-based inpainting model. As shown in the table below, ConV demonstrates strong detection performance on this form of partial image manipulation, highlighting its effectiveness beyond fully generated content.

Q7. Page 4, Line 134: The text states: “we denote $x_M(x_g)$ as $x_M$ for simplicity.” Should here be referring to the natural image $x_M(x_n)$ instead?

We apologize for any confusion. The notation $\mathbf{x}\_{\mathcal{M}}(\mathbf{x}\_g)$ denotes the projection of a generated image $\mathbf{x}\_g$ onto the natural image manifold $\mathcal{M}$; that is, it represents the closest point to $\mathbf{x}\_g$ lying on $\mathcal{M}$. In contrast, a natural image $\mathbf{x}\_n$ is already assumed to reside on the manifold, and thus its projection satisfies $\mathbf{x}\_{\mathcal{M}}(\mathbf{x}\_n) = \mathbf{x}\_n$.

Reference

[1] Spatial Transformer Networks, Max Jaderberg, Karen Simonyan, Andrew Zisserman, Koray Kavukcuoglu, NIPS 2015

[2] Deformable Convolutional Networks, Jifeng Dai, Haozhi Qi, Yuwen Xiong, Yi Li, Guodong Zhang, Han Hu, ICCV 2017

Dear Reviewer #QsoV,

Thank you very much for your valuable time invested in reviewing our manuscript and for your insightful comments, which have greatly guided our revisions.

We have carefully addressed each of your points in the revised manuscript and the accompanying response, and we hope these modifications adequately address your concerns.

We understand your schedule is extremely busy, but as the discussion deadline is fast approaching, we would be most grateful if you could kindly take a moment to review our response. This would help clarify whether there are any remaining points you wish to discuss further, ensuring we can address them promptly.

Please do not hesitate to let us know if you have any additional questions or require further clarification—we are fully prepared to provide detailed responses at your convenience.

Thank you again for your guidance and support.

Best regards,

The Authors of Paper #16115

import torch
import torch.nn as nn
import torch.nn.functional as F
import math

_RGB2YUV = torch.tensor([[ 0.299,    0.587,    0.114 ],
                         [-0.14713, -0.28886,  0.436 ],
                         [ 0.615,   -0.51499, -0.10001]], dtype=torch.float32)
_YUV2RGB = torch.tensor([[1.0,   0.0,      1.13983],
                         [1.0,  -0.39465, -0.58060],
                         [1.0,   2.03211,  0.0    ]], dtype=torch.float32)

class DifferentiableColorTransform(nn.Module):
    def __init__(self,
                 brightness_range=(0.0, 0.2),
                 contrast_range=(0.8, 1.2),
                 saturation_range=(0.8, 1.2),
                 hue_range=(-0.1, 0.1)): 
        super().__init__()
        self.brightness_range = brightness_range
        self.contrast_range   = contrast_range
        self.saturation_range = saturation_range
        self.hue_range        = hue_range

        self.register_buffer('rgb2yuv', _RGB2YUV.clone())
        self.register_buffer('yuv2rgb', _YUV2RGB.clone())
        self.register_buffer('luma', torch.tensor([0.299, 0.587, 0.114]).view(1,3,1,1))

    def forward(self, x: torch.Tensor) -> torch.Tensor:
       
        B, C, H, W = x.shape
        device, dtype = x.device, x.dtype

        luma    = self.luma.to(device=device, dtype=dtype)
        rgb2yuv = self.rgb2yuv.to(device=device, dtype=dtype)
        yuv2rgb = self.yuv2rgb.to(device=device, dtype=dtype)

        
        def ru(lo, hi, shape):
            return lo + (hi - lo) * torch.rand(shape, device=device, dtype=dtype)

        b     = ru(self.brightness_range[0], self.brightness_range[1], (B,1,1,1)) 
        c     = ru(self.contrast_range[0],   self.contrast_range[1],   (B,1,1,1))  
        s     = ru(self.saturation_range[0], self.saturation_range[1], (B,1,1,1))  
        theta = ru(self.hue_range[0],        self.hue_range[1],        (B,1,1,1))  

        
        mu = (x * luma).sum(dim=1, keepdim=True)  
        x  = (x - mu) * c + mu + b                

       
        gray = (x * luma).sum(dim=1, keepdim=True) 
        x    = gray + s * (x - gray)

        
        x_perm = x.permute(0,2,3,1)               
        YUV    = torch.matmul(x_perm, rgb2yuv.T)  
        Y = YUV[..., 0]                           
        U = YUV[..., 1]                            
        V = YUV[..., 2]                            

       
        cos_t = torch.cos(theta).view(B,1,1).expand(B,H,W)
        sin_t = torch.sin(theta).view(B,1,1).expand(B,H,W)

        U_rot = cos_t * U - sin_t * V              
        V_rot = sin_t * U + cos_t * V              

        YUV_r = torch.stack([Y, U_rot, V_rot], dim=-1)   
        RGB   = torch.matmul(YUV_r, yuv2rgb.T)           
        x     = RGB.permute(0,3,1,2)                     
        return x

    


class DifferentiableFlipTransform(nn.Module):  
    def __init__(self):
        super().__init__()

    def horizontal_flip(self, image):  
    
        B, C, H, W = image.shape

        grid_y, grid_x = torch.meshgrid(
            torch.linspace(-1, 1, H, device=image.device),
            torch.linspace(-1, 1, W, device=image.device),
            indexing='ij'
        )  

        grid = torch.stack((-grid_x, grid_y), dim=-1)  
        grid = grid.unsqueeze(0).repeat(B, 1, 1, 1)    
        flipped = torch.nn.functional.grid_sample(image, grid, mode='bilinear', align_corners=False)
        return flipped
    
    def vertical_flip(self, image):  

        B, C, H, W = image.shape

        grid_y, grid_x = torch.meshgrid(
            torch.linspace(-1, 1, H, device=image.device),
            torch.linspace(-1, 1, W, device=image.device),
            indexing='ij'
        )

        
        grid = torch.stack((grid_x, -grid_y), dim=-1) 
        grid = grid.unsqueeze(0).repeat(B, 1, 1, 1)
        
        flipped = torch.nn.functional.grid_sample(image, grid, mode='bilinear', align_corners=False)
        return flipped
    
    def forward(self, x, flip_type='horizontal'):
        
        if flip_type == 'horizontal':
            return self.horizontal_flip(x)
        elif flip_type == 'vertical':
            return self.vertical_flip(x)
        elif flip_type == 'both':
            x_h = self.horizontal_flip(x)
            return self.vertical_flip(x_h)
        else:
            return x

class DifferentiableAffineTransform(nn.Module):
    def __init__(self,
                 rotation_range=(-10.0, 10.0),        
                 scale_range=(0.95, 1.05),
                 translation_range=(-0.05, 0.05),     
                 shear_x_range=(-5.0, 5.0),          
                 shear_y_range=(-5.0, 5.0),           
                 padding_mode='border'):
        super().__init__()
        self.rotation_range    = rotation_range
        self.scale_range       = scale_range
        self.translation_range = translation_range
        self.shear_x_range     = shear_x_range
        self.shear_y_range     = shear_y_range
        self.padding_mode      = padding_mode

    @staticmethod
    def _ru(lo, hi, shape, device, dtype):
        return lo + (hi - lo) * torch.rand(shape, device=device, dtype=dtype)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        B, C, H, W = x.shape
        device, dtype = x.device, x.dtype

       
        ang_deg = self._ru(*self.rotation_range,    (B,), device, dtype)
        sx      = self._ru(*self.scale_range,       (B,), device, dtype)
        sy      = self._ru(*self.scale_range,       (B,), device, dtype)
        tx      = self._ru(*self.translation_range, (B,), device, dtype)  
        ty      = self._ru(*self.translation_range, (B,), device, dtype)  
        shx_deg = self._ru(*self.shear_x_range,     (B,), device, dtype)
        shy_deg = self._ru(*self.shear_y_range,     (B,), device, dtype)

        ang = ang_deg * (math.pi/180.0)
        shx = shx_deg * (math.pi/180.0)
        shy = shy_deg * (math.pi/180.0)

        cos_a, sin_a = torch.cos(ang), torch.sin(ang)
        tan_shx, tan_shy = torch.tan(shx), torch.tan(shy)

        
        cx = (W - 1) / 2.0
        cy = (H - 1) / 2.0
        
        sxn = 2.0 / (W - 1)
        syn = 2.0 / (H - 1)
        
        cx_n = (cx * sxn)
        cy_n = (cy * syn)

        I = torch.eye(3, device=device, dtype=dtype).unsqueeze(0).expand(B,3,3).clone()

        
        T_c   = I.clone()
        T_c[:,0,2] = cx_n
        T_c[:,1,2] = cy_n
        
        T_ci  = I.clone()
        T_ci[:,0,2] = -cx_n
        T_ci[:,1,2] = -cy_n

        
        S = I.clone()
        S[:,0,0] = sx
        S[:,1,1] = sy

        
        R = I.clone()
        R[:,0,0] =  cos_a
        R[:,0,1] = -sin_a
        R[:,1,0] =  sin_a
        R[:,1,1] =  cos_a

        
        Shx = I.clone()
        Shx[:,0,1] = tan_shx
        Shy = I.clone()
        Shy[:,1,0] = tan_shy
        Sh = Shy @ Shx

        
        T = I.clone()
        T[:,0,2] = tx
        T[:,1,2] = ty

        
        M = T @ T_c @ Sh @ R @ S @ T_ci    

       
        theta = M[:, :2, :]

        grid = F.affine_grid(theta, size=x.size(), align_corners=False)
        

        y = F.grid_sample(x, grid, mode='bilinear',
                          padding_mode=self.padding_mode, align_corners=False)
        return y

Dear Reviewer QsoV,

Thank you for your thoughtful engagement and the opportunity for this valuable technical discussion.

Addressing Concern 1: The new results are helpful, yet I believe they can still be explained from the viewpoint of augmentation invariance. This alternative interpretation does not necessarily contradict your motivation, but suggests that augmentation robustness remains a simpler explanation of the observed behavior.

We appreciate your perspective connecting our approach to augmentation robustness in self-supervised learning. This insight aligns with prior work [1,2], and we agree that our method can be intuitively understood through the lens of augmentation invariance, grounding it in these established principles [1,2].

Addressing Concern 2: Could the author please elaborate on the exact procedure used to compute the gradients of $f_1$​ and $f_2$​? Am I correct that the gradients you report are $\nabla\_{\mathbf{x}} f_i(\mathbf{x})$, evaluated with respect to the unaugmented input tensor and averaged over the network parameters?

Thank you for this important clarification request. In our method, gradients are computed with respect to the original input pixels (not model parameters), yielding gradient maps with the same spatial dimensions as the input image. We then measure the cosine similarity between these two gradient maps.

Implementation of Differentiable Transformations: It is not obvious for discrete operations such as horizontal flips or certain color manipulations. A brief description (or pseudocode) of how the augmentation in the pipeline is made differentiable would be very helpful.

Following your valuable suggestion, we provide implementation details for our differentiable transformation pipeline:

• Differentiable affine transforms: rotation, scaling, translation, and shearing;

• Differentiable color transforms: brightness, contrast, saturation, and hue adjustments;

• Differentiable flip transforms: horizontal and vertical flips.

All transformations maintain end-to-end differentiability through PyTorch's automatic differentiation, enabling gradient computation through the entire pipeline.

The connection to augmentation robustness you identified offers novel theoretical and empirical perspectives for our proposed orthogonal principle, paired with its realization using data augmentation.

We hope these clarifications address your concerns and highlight our contributions to the field. We would greatly appreciate your consideration of these details in your final assessment.

[1] Provable Guarantees for Self-Supervised Deep Learning with Spectral Contrastive Loss, NeurIPS 2021

[2] Understanding Augmentation-based Self-Supervised Representation Learning via RKHS Approximation and Regression, ICLR 2024

We are truly grateful for the reviewers' dedicated efforts. The valuable comments greatly improve the quality of our work. We provide the following answers to the reviewers' concerns.

Q1. The writing in this paper requires significant improvement. Some sentences are confusing and difficult to read, such as the first paragraph of Section 2.1. Also, there is missing information; for instance, in Figure 2, it is unclear which color represents real images and which represents fake images. There are also formatting issues, such as inconsistent spacing observed in line 130. Moreover, there are inconsistencies in notation usage. For example, in line 107, "x_n" is used to denote natural images, but throughout the rest of the paper, "x_m" appears to be used instead.

We express our gratitude for the reviewer’s kind suggestion. We have added the following clarification to our revision.

• In Figure 2, red dots denote the feature representations of natural images, while purple dots represent those of generated images.
• The terms $\mathbf{x}\_{\mathcal{M}}$ and $\mathbf{x}\_{\mathcal{n}}$ convey distinct meanings: $\mathbf{x}\_{\mathcal{n}}$ corresponds to the feature representation of a natural image, whereas $\mathbf{x}\_{\mathcal{M}}$ represents the projection of a generated image’s features onto the manifold of natural images.

Q2. Although ConV achieves strong results as indicated in Table 1, it seems that the primary contributing factor is the pre-trained model, such as DINOv2 (refer to line 269). This factor should not be disregarded and warrants further discussion. This is my major concern about this paper.

Thank you for your insightful comment. To further validate the effectiveness of our proposed method, we conducted additional experiments across a range of backbone models, including MoCo, SwAV, DINO, CLIP, and SigLIP.

ConV operates without any additional training and relies solely on a pre-trained feature extractor. Its performance is therefore contingent on the extractor’s ability to strike a delicate balance: accurately capturing the intrinsic structure of natural images while avoiding overgeneralization to generated content. As a result, ConV is inherently sensitive to the choice of feature extractor, as demonstrated in the results reported below.

Nevertheless, this sensitivity can be substantially alleviated through fine-tuning the feature extractor, as further evidenced by the performance improvements shown in the accompanying table.

Thanks again for your constructive comments. Accordingly, the above results have been added to our revision.

Q3. Why is the first item, starting on line 81, considered the main contribution of this paper?

Most AI-generated image detection methods involve training a binary classifier for natural images and generated images. This approach implicitly assumes that generated images share certain shared features. However, as generative models continue to evolve, this assumption may be challenged. Instead, in this paper, we focus on how to distinguish between natural images and generated images by simply fitting the natural distribution, thereby avoiding any prior assumptions about generated images.

Q4. Does this method remain effective when applied to larger and more recent models, such as Flux, that are trained on extensive datasets like LAION?

Thank you for your constructive suggestion. We further assessed the performance of ConV on the Flux model by constructing a new evaluation dataset comprising 6,000 images generated by the FLUX.1 [dev] model, alongside natural images sampled from ImageNet. As shown in the table below, ConV demonstrates strong performance on this previously unseen generative model, further highlighting the generalizability of our approach.

Q5. Why does the performance of the training-free method on DiT significantly lag behind that of the baseline in Tab.1?

We speculate that this phenomenon can be intuitively explained using the FID (Fréchet Inception Distance) score. The FID score is a commonly used evaluation metric for generative models, primarily assessing the quality of the generative model by comparing the distribution differences between generated images and natural images in the feature space. A lower FID score indicates that the distribution of the generated images is closer to that of the natural images. As shown in the table below, we have listed the FID scores of several generative models, along with the detection performance of ConV on these models. It is clearly evident that as the FID score of the generative model increases, the detection performance of ConV improves. This is because ConV leverages the differences in data distribution between natural images and generated images for detection. When the differences in data distribution between generated images and natural images are small, directly using ConV may not yield satisfactory results. In such cases, we can employ the proposed F-ConV, which utilizes manifold learning to push generated images out of the natural distribution, thereby increasing the distribution differences between the two.

We are truly grateful for the reviewers' dedicated efforts. The valuable comments greatly improve the quality of our work. We provide the following answers to the reviewers' concerns.

Q1. The performance is sensitive to the choice of feature extractor.

We express our gratitude for the reviewer’s insightful comment regarding the sensitivity of our method to the choice of feature extractor. As ConV operates without additional training and relies solely on a pre-trained feature extractor, its performance hinges on the extractor’s ability to maintain a precise balance: effectively capturing the characteristics of natural images while avoiding overgeneralization to generated images. This results in ConV being sensitive to the feature extractor used. However, this sensitivity can be mitigated through fine-tuning the feature extractor, as evidenced by the results presented in the table below.

Thanks again for your inspiring comments. We have added the above results to our revision.

Q2. L542 mentions that the decision threshold is selected automatically to maximize the separation between natural and generated images. Is this performed per-domain/dataset or generally across all datasets/domains?

Thanks for pointing out this potentially confusing description issue. We have added the following explanations to our revision. To optimize overall accuracy, we can establish the classification threshold at a value that maximizes the distinction between natural and generated images. However, in real-world applications, this approach may differ.

For instance, to prioritize the detection of generated images, administrators may set a higher threshold, classifying only samples with similarity scores approaching 1 as natural images. This is consistent with the motivation of leveraging AUROC and AP as the main metric for evaluation.

Regarding the threshold of accuracy, we used the training set from GenImage to select a threshold and applied that threshold to all test sets. As shown in the table below, this approach resulted in a slight performance difference.

Q3. Related to this, how does the cosine similarity distribution for natural vs. generated images compare across domains and datasets? Are there cases where similarities for generated images of one dataset are higher than those of natural images of another dataset? If this is the case, in practical, generic situations where natural images encompass all non-generated images, and synthetic images can come from any model with any training data, how should the decision threshold be decided?

We acknowledge that generated images can exhibit similarity scores surpassing those of natural images, which precludes achieving a 100% accuracy rate. In our experiments, to optimize overall accuracy, we establish the classification threshold at a value that maximizes the distinction between natural and generated images. However, in real-world applications, this approach may differ. For instance, to prioritize the detection of generated images, administrators may set a higher threshold, classifying only samples with similarity scores approaching 1 as natural images.

Q4. While it is intuitive to use the same transformations as those used in the feature extractor’s training, are there any empirical analysis to determine if all of them are truly necessary, or are specific ones that contribute more and would suffice (holding the number of transformations constant)?

We express our appreciation for the reviewer’s valuable suggestion. To further investigate the impact of data transformations, we conducted additional ablation studies on the transformation functions employed. The experimental results show that the three transformations all have an impact on the detection effect.

We are truly grateful for the reviewers' dedicated efforts. The valuable comments greatly improve the quality of our work. We provide the following answers to the reviewers' concerns.

Q1. Assumption of orthogonal gradient subspaces lacks empirical validation. Can the authors provide empirical validation for the assumption that the gradients lie in orthogonal subspaces for natural vs. generated images?

Thanks for your constructive feedback! The mentioned results would provide a straightforward approach to verify the effectiveness of our method, thereby significantly improving the quality of our work. We will provide the complete empirical validation results during the discussion period.

Q2. Generalization with other backbones is not assessed. How does the detection performance change if a smaller or weaker self-supervised backbone is used instead of DINOv2?

We express our gratitude for the reviewer’s insightful comment. To further substantiate the efficacy of our proposed method, we conducted additional experiments using various backbone models, including MoCo, SwAV, DINO, CLIP, and SigLIP. The experimental results, presented in the table below, demonstrate that ConV maintains robust detection performance even when applied to less powerful models.

Q3. F-ConV loss components are not ablated. Could the authors provide ablation studies isolating the shaping and consistency losses in F-ConV?

Thanks for your constructive suggestion. We further conducted ablation experiments on this. The experimental results are shown in the table below.

Q4. No analysis of failure cases is provided.

We express our gratitude for the reviewer’s valuable suggestion. In the revised manuscript, we incorporate an analysis of failure cases as recommended. Our findings indicate that highly realistic generated images typically exhibit minimal feature variations pre- and post-transformation, resulting in misclassification.

Q5. The heavy mathematical formalism might limit accessibility.

We express our appreciation for the reviewer’s valuable suggestion. In the revised manuscript, we incorporate more detailed and precise explanations to enhance clarity and accessibility.

Q6. How sensitive is the method to the choice of the transformation function $h(\cdot)$? Are some augmentations more effective than others?

We thank the authors for the valuable suggestions. To address the query regarding the sensitivity of our method to the choice of transformation function $h(\cdot)$, we conducted additional ablation studies evaluating the effectiveness of various transformation functions. The results, presented in the table below, indicate that the three transformations examined exhibit comparable performance.

Q7. How is the performance better than a simpler setup where we train an autoencoder over training images and detect generated images if the loss is higher than a threshold?

We express our appreciation for the reviewer’s insightful comment. The approach highlighted, a well-established method in anomaly detection, leverages reconstruction loss through autoencoders. These models are typically trained on normal samples, enabling effective reconstruction of in-distribution data but yielding higher reconstruction errors for anomalous samples. However, in the context of AI generated image detection, the diverse distributional characteristics of natural images necessitate training an autoencoder on an extensive dataset, such as the LVD-142M dataset employed in DINOv2, to adequately capture the natural image distribution. Due to resource and time constraints, training an autoencoder on such a large-scale dataset is infeasible within the scope of this study, precluding a fair comparison with this method.