✨ feat(image processing): add MinMax pre-processing to image pipeline

- add support【】for MinMax pre-processing in predict_image_with_html
- add MinMax processing to ela_images output
- import minmax_preprocess function from utils.minmax.py
- adjust gradient processing intensity value

✅ test(gradient): test gradient processing

- test default behavior of gradient processing
- ensure correct default values for intensity and blue_mode
- validate intensity adjustment

app.py

@@ -9,6 +9,7 @@ import io
 import logging
 from utils.utils import softmax, augment_image, convert_pil_to_bytes, ELA
 from utils.gradient import gradient_processing
+from utils.minmax import preprocess as minmax_preprocess
 
 
 # Configure logging
@@ -232,6 +233,7 @@ def predict_image_with_html(img, confidence_threshold, augment_methods, rotate_d
     img_pil, results = predict_image(img_pil, confidence_threshold)
     
     gradient_image = gradient_processing(img_pil)  # Added gradient processing
+    minmax_image = minmax_preprocess(img_pil)  # Added MinMax processing
 
     # Generate ELA images with different presets
     ela_img_1 = ELA(img_pil, scale=100, alpha=0.66)
@@ -239,7 +241,7 @@ def predict_image_with_html(img, confidence_threshold, augment_methods, rotate_d
     ela_img_3 = ELA(img_pil, scale=50, alpha=0.5)
     ela_img_4 = ELA(img_pil, scale=25, alpha=0.85)
     
-    ela_images = [ela_img_1, ela_img_2, ela_img_3, ela_img_4, gradient_image]
+    ela_images = [ela_img_1, ela_img_2, ela_img_3, ela_img_4, gradient_image, minmax_image]
     
     html_content = generate_results_html(results)
     return img_pil, ela_images, html_content

utils/gradient.py

@@ -18,7 +18,7 @@ def create_lut(intensity, gamma):
         lut[i, 0, 2] = min(255, max(0, i + intensity))
     return lut
 
-def gradient_processing(image, intensity=95, blue_mode="Abs", invert=False, equalize=False):
+def gradient_processing(image, intensity=90, blue_mode="Abs", invert=False, equalize=False):
     image = np.array(image)
     dx, dy = cv.spatialGradient(cv.cvtColor(image, cv.COLOR_BGR2GRAY))
     intensity = int(intensity / 100 * 127)

utils/minmax.py

@@ -0,0 +1,81 @@
+import numpy as np
+import cv2 as cv
+from PIL import Image
+
+def norm_mat(mat):
+    return cv.normalize(mat, None, 0, 255, cv.NORM_MINMAX).astype(np.uint8)
+
+def minmax_dev(patch, mask):
+    c = patch[1, 1]
+    minimum, maximum, _, _ = cv.minMaxLoc(patch, mask)
+    if c < minimum:
+        return -1
+    if c > maximum:
+        return +1
+    return 0
+
+def blk_filter(img, radius):
+    result = np.zeros_like(img, np.float32)
+    rows, cols = result.shape
+    block = 2 * radius + 1
+    for i in range(radius, rows, block):
+        for j in range(radius, cols, block):
+            result[
+                i - radius : i + radius + 1, j - radius : j + radius + 1
+            ] = np.std(
+                img[i - radius : i + radius + 1, j - radius : j + radius + 1]
+            )
+    return cv.normalize(result, None, 0, 127, cv.NORM_MINMAX, cv.CV_8UC1)
+
+
+def preprocess(image, channel=0, radius=0):
+    if channel == 0:
+        img = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
+    elif channel == 4:
+        b, g, r = cv.split(image.astype(np.float64))
+        img = cv.sqrt(cv.pow(b, 2) + cv.pow(g, 2) + cv.pow(r, 2))
+    else:
+        img = image[:, :, 3 - channel]
+    kernel = 3
+    border = kernel // 2
+    shape = (img.shape[0] - kernel + 1, img.shape[1] - kernel + 1, kernel, kernel)
+    strides = 2 * img.strides
+    patches = np.lib.stride_tricks.as_strided(img, shape=shape, strides=strides)
+    patches = patches.reshape((-1, kernel, kernel))
+    mask = np.full((kernel, kernel), 255, dtype=np.uint8)
+    mask[border, border] = 0
+    blocks = [0] * shape[0] * shape[1]
+    for i, patch in enumerate(patches):
+        blocks[i] = minmax_dev(patch, mask)
+    output = np.array(blocks).reshape(shape[:-2])
+    output = cv.copyMakeBorder(
+        output, border, border, border, border, cv.BORDER_CONSTANT
+    )
+    low = output == -1
+    high = output == +1
+    minmax = np.zeros_like(image)
+    if radius > 0:
+        radius += 3
+        low = blk_filter(low, radius)
+        high = blk_filter(high, radius)
+        if channel <= 2:
+            minmax[:, :, 2 - channel] = low
+            minmax[:, :, 2 - channel] += high
+        else:
+            minmax = np.repeat(low[:, :, np.newaxis], 3, axis=2)
+            minmax += np.repeat(high[:, :, np.newaxis], 3, axis=2)
+        minmax = norm_mat(minmax)
+    else:
+        if channel == 0:
+            minmax[low] = [0, 0, 255]
+            minmax[high] = [0, 0, 255]
+        elif channel == 1:
+            minmax[low] = [0, 255, 0]
+            minmax[high] = [0, 255, 0]
+        elif channel == 2:
+            minmax[low] = [255, 0, 0]
+            minmax[high] = [255, 0, 0]
+        elif channel == 3:
+            minmax[low] = [255, 255, 255]
+            minmax[high] = [255, 255, 255]
+    return Image.fromarray(minmax)