✨ feat(image): add gradient processing in predict_image Function

-Body Mainly：【main】+

- add gradient processing to predict image pipeline using new utils module
- introduce new gradient processing parameters for enhanced image analysis

✨ feat(utils): add gradient processing utility

- Body Process

-add gradient processing utility with various configuration options

- Body Methods
-add normalization, equalization, and LUT creation for gradient processing
-add spatial gradient calculation for image analysis
-implement blue mode options for gradient processing

- Body Mode
-images and dictionaries properly formatted according to function requirements
-utiilities imports updated for type relevance
-variables initialized for reuse and efficiency

πŸ”§ chore(utils): add python eol format

-update utils/gradiend.py for better visual formatting

app.py

@@ -8,6 +8,7 @@ import numpy as np
 import io
 import logging
 from utils.utils import softmax, augment_image, convert_pil_to_bytes, ELA
+from utils.gradient import gradient_processing
 
 
 # Configure logging
@@ -230,12 +231,15 @@ def predict_image_with_html(img, confidence_threshold, augment_methods, rotate_d
         img_pil = img
     img_pil, results = predict_image(img_pil, confidence_threshold)
     
+    gradient_image = gradient_processing(img_pil)  # Added gradient processing
+
     # Generate ELA images with different presets
-    ela_img_1 = ELA(img_pil, scale=77, alpha=0.66)
-    ela_img_2 = ELA(img_pil, scale=100, alpha=0.8)
+    ela_img_1 = ELA(img_pil, scale=100, alpha=0.66)
+    ela_img_2 = ELA(img_pil, scale=75, alpha=0.8)
     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_images = [ela_img_1, ela_img_2, ela_img_3, ela_img_4, gradient_image]
     
     html_content = generate_results_html(results)
     return img_pil, ela_images, html_content

utils/gradient.py

@@ -0,0 +1,50 @@
+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 equalize_img(img):
+    ycrcb = cv.cvtColor(img, cv.COLOR_BGR2YCrCb)
+    ycrcb[:, :, 0] = cv.equalizeHist(ycrcb[:, :, 0])
+    return cv.cvtColor(ycrcb, cv.COLOR_YCrCb2BGR)
+
+def create_lut(intensity, gamma):
+    lut = np.zeros((256, 1, 3), dtype=np.uint8)
+    for i in range(256):
+        lut[i, 0, 0] = min(255, max(0, i + intensity))
+        lut[i, 0, 1] = min(255, max(0, i + intensity))
+        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):
+    image = np.array(image)
+    dx, dy = cv.spatialGradient(cv.cvtColor(image, cv.COLOR_BGR2GRAY))
+    intensity = int(intensity / 100 * 127)
+    if invert:
+        dx = (-dx).astype(np.float32)
+        dy = (-dy).astype(np.float32)
+    else:
+        dx = (+dx).astype(np.float32)
+        dy = (+dy).astype(np.float32)
+    dx_abs = np.abs(dx)
+    dy_abs = np.abs(dy)
+    red = ((dx / np.max(dx_abs) * 127) + 127).astype(np.uint8)
+    green = ((dy / np.max(dy_abs) * 127) + 127).astype(np.uint8)
+    if blue_mode == "None":
+        blue = np.zeros_like(red)
+    elif blue_mode == "Flat":
+        blue = np.full_like(red, 255)
+    elif blue_mode == "Abs":
+        blue = norm_mat(dx_abs + dy_abs)
+    elif blue_mode == "Norm":
+        blue = norm_mat(np.linalg.norm(cv.merge((red, green)), axis=2))
+    else:
+        blue = None
+    gradient = cv.merge([blue, green, red])
+    if equalize:
+        gradient = equalize_img(gradient)
+    elif intensity > 0:
+        gradient = cv.LUT(gradient, create_lut(intensity, intensity))
+    return Image.fromarray(gradient)