UPDATED: Updated ELA image processing in app.py and ela.py

- Updated ELA image processing in app.py by replacing the previous ELA image generation with two passes: standard analysis and enhanced visibility.
- Updated genELA() function in ela.py to improve the:
- Replaced the previous implementation with a new implementation.
- Added arguments for quality, scale, contrast, linear, and grayscale.
- Compressed the input image using JPEG compression.
- Calculated the difference compressed images.
- Applied scaling to the difference image.
- Applied contrast adjustment to the resulting image.
- Added support for linear difference and grayscale output.
- Returned the processed ELA image.

app.py

@@ -277,11 +277,13 @@ def predict_image_with_html(img, confidence_threshold, augment_methods, rotate_d
     gradient_image = gradient_processing(img_np)  # Added gradient processing
     minmax_image = minmax_preprocess(img_np)  # Added MinMax processing
 
-    # Generate ELA images with different presets
-    ela_img_1 = ELA(img_pil, scale=100, alpha=0.66)
-    ela_img_2 = ELA(img_pil, scale=50, alpha=0.5)
+    # First pass - standard analysis
+    ela1 = ELA(img_np, quality=75, scale=50, contrast=20, linear=False, grayscale=True)
+
+    # Second pass - enhanced visibility
+    ela2 = ELA(img_np, quality=75, scale=75, contrast=25, linear=False, grayscale=True)
     
-    forensics_images = [img_pil, ela_img_1, ela_img_2, gradient_image, minmax_image]
+    forensics_images = [img_pil, ela1, ela2, gradient_image, minmax_image]
     
     html_content = generate_results_html(results)
     return img_pil, forensics_images, html_content

utils/ela.py

@@ -1,21 +1,63 @@
 import numpy as np
-import io
-from PIL import Image, ImageFilter, ImageChops
-from torchvision import transforms
+import cv2 as cv
+from time import time
 
-def genELA(img_pil, scale=77, alpha=0.66):
-    # Error Level Analysis for basic image forensics
-    original = img_pil.copy()          # open up the input image
-    temp_path = 'temp.jpg'             # temporary image name to save the ELA to
-    original.save(temp_path, quality=95)     # re-save the image with a quality of 95%
-    temporary = Image.open(temp_path)        # open up the re-saved image
+def compress_jpg(image, quality):
+    """Compress image using JPEG compression."""
+    encode_param = [int(cv.IMWRITE_JPEG_QUALITY), quality]
+    _, buffer = cv.imencode('.jpg', image, encode_param)
+    return cv.imdecode(buffer, cv.IMREAD_COLOR)
 
-    diff = ImageChops.difference(original, temporary)   # load in the images to look at pixel by pixel differences
-    d = diff.load()                     # load the image into a variable
-    WIDTH, HEIGHT = diff.size           # set the size into a tuple
-    for x in range(WIDTH):                                  # row by row
-        for y in range(HEIGHT):                             # column by column
-            d[x, y] = tuple(k * scale for k in d[x, y])     # set the pixels to their x,y & color based on error
+def desaturate(image):
+    """Convert image to grayscale."""
+    return cv.cvtColor(image, cv.COLOR_BGR2GRAY)
 
-    new_img = ImageChops.blend(temporary, diff, alpha)      # blend the original w/ the ELA @ a set alpha/transparency
-    return new_img
+def create_lut(contrast, brightness):
+    """Create lookup table for contrast and brightness adjustment."""
+    lut = np.arange(256, dtype=np.uint8)
+    lut = cv.LUT(lut, lut)
+    lut = cv.convertScaleAbs(lut, None, contrast/128, brightness)
+    return lut
+
+def elapsed_time(start):
+    """Calculate elapsed time since start."""
+    return f"{time() - start:.3f}s"
+
+def genELA(img, quality=75, scale=50, contrast=20, linear=False, grayscale=False):
+    """
+    Perform Error Level Analysis on an image.
+    
+    Args:
+        img: Input image (numpy array)
+        quality: JPEG compression quality (1-100)
+        scale: Output multiplicative gain (1-100)
+        contrast: Output tonality compression (0-100)
+        linear: Whether to use linear difference
+        grayscale: Whether to output grayscale image
+    
+    Returns:
+        Processed ELA image
+    """
+    # Convert image to float32 and normalize
+    original = img.astype(np.float32) / 255
+    
+    # Compress image
+    compressed = compress_jpg(img, quality)
+    compressed = compressed.astype(np.float32) / 255
+    
+    # Calculate difference based on mode
+    if not linear:
+        difference = cv.absdiff(original, compressed)
+        ela = cv.convertScaleAbs(cv.sqrt(difference) * 255, None, scale / 20)
+    else:
+        ela = cv.convertScaleAbs(cv.subtract(compressed, img), None, scale)
+    
+    # Apply contrast adjustment
+    contrast_value = int(contrast / 100 * 128)
+    ela = cv.LUT(ela, create_lut(contrast_value, contrast_value))
+    
+    # Convert to grayscale if requested
+    if grayscale:
+        ela = desaturate(ela)
+    
+    return ela