Update app.py

app.py

@@ -14,9 +14,6 @@ def _enhance_for_display(pil_img, scale: float):
     return Image.fromarray(arr)
 
 def error_level_analysis(pil_img: Image.Image, quality: int = 90):
-    """
-    Save as JPEG at given quality, diff vs original, return (ela_image, mean_intensity in [0,1]).
-    """
     img = pil_img.convert("RGB")
     with io.BytesIO() as buf:
         img.save(buf, "JPEG", quality=quality)
@@ -32,23 +29,15 @@ def error_level_analysis(pil_img: Image.Image, quality: int = 90):
     return ela_vis, mean_intensity
 
 def ela_sweep_mean(pil_img, qualities=(95, 90, 85)):
-    """
-    Try multiple JPEG qualities and take the max ELA response.
-    Returns (peak, avg) for a small compression-aware adjustment later.
-    """
     vals = []
     for q in qualities:
         _, m = error_level_analysis(pil_img, quality=q)
         vals.append(m)
     return float(max(vals)), float(np.mean(vals))
 
-# ====================== Frequency & Noise (accept a face mask) ======================
+# ====================== Frequency & Noise (support face masks) ======================
 
 def fft_high_freq_ratio(pil_img: Image.Image, mask=None):
-    """
-    High-frequency energy ratio from 2D FFT magnitude on Y (luma) channel.
-    If mask provided (float [0,1]), analyze only masked region.
-    """
     y = pil_img.convert("YCbCr").split()[0]
     gray = np.array(y, dtype=np.float32) / 255.0
     if mask is not None:
@@ -70,10 +59,6 @@ def fft_high_freq_ratio(pil_img: Image.Image, mask=None):
     return None, float(hf_ratio)
 
 def noise_inconsistency(pil_img: Image.Image, mask=None):
-    """
-    Laplacian sharpness variability on Y channel. Higher => more inconsistent texture.
-    If mask provided, restrict to masked region.
-    """
     y = pil_img.convert("YCbCr").split()[0]
     img = np.array(y, dtype=np.float32)
     if mask is not None:
@@ -82,7 +67,6 @@ def noise_inconsistency(pil_img: Image.Image, mask=None):
     lap = cv2.Laplacian(img, cv2.CV_32F, ksize=3)
     lap_abs = np.abs(lap)
 
-    # Light normalization for stability (visual not used here)
     _ = exposure.equalize_adapthist(
         (lap_abs / (lap_abs.max() + 1e-9)).astype("float32"), clip_limit=0.01
     )
@@ -99,7 +83,7 @@ def noise_inconsistency(pil_img: Image.Image, mask=None):
         return None, 0.0
     vals = np.array(vals, dtype=np.float32)
     score = float(vals.std() / (vals.mean() + 1e-9))
-    return None, float(np.tanh(score / 5.0))  # squash to ~[0,1]
+    return None, float(np.tanh(score / 5.0))
 
 # ====================== Face crop + oval mask ======================
 
@@ -108,9 +92,6 @@ _mp_face = mp.solutions.face_detection.FaceDetection(
 )
 
 def crop_face(pil_img, pad=0.25):
-    """
-    Crop to the largest detected face and add a margin (pad). Fallback to original if none.
-    """
     img = np.array(pil_img.convert("RGB"))
     h, w = img.shape[:2]
     res = _mp_face.process(cv2.cvtColor(img, cv2.COLOR_RGB2BGR))
@@ -119,15 +100,12 @@ def crop_face(pil_img, pad=0.25):
     det = max(res.detections, key=lambda d: d.location_data.relative_bounding_box.width)
     b = det.location_data.relative_bounding_box
     x, y, bw, bh = b.xmin, b.ymin, b.width, b.height
-    x1 = int(max(0, (x - pad * bw) * w)); y1 = int(max(0, (y - pad * bh) * h))
-    x2 = int(min(w, (x + bw + pad * bw) * w)); y2 = int(min(h, (y + bh + pad * bh) * h))
+    x1 = int(max(0, (x - pad*bw) * w)); y1 = int(max(0, (y - pad*bh) * h))
+    x2 = int(min(w, (x + bw + pad*bw) * w)); y2 = int(min(h, (y + bh + pad*bh) * h))
     face = Image.fromarray(img[y1:y2, x1:x2])
     return face if face.size[0] > 20 and face.size[1] > 20 else pil_img
 
-def face_oval_mask(img_pil, shrink=0.88):
-    """
-    Create an elliptical face mask (float [0,1]) to ignore hair/neck/jewelry/background.
-    """
+def face_oval_mask(img_pil, shrink=0.80):
     w, h = img_pil.size
     mask = Image.new("L", (w, h), 0)
     draw = ImageDraw.Draw(mask)
@@ -135,19 +113,32 @@ def face_oval_mask(img_pil, shrink=0.88):
     draw.ellipse((dx, dy, w - dx, h - dy), fill=255)
     return np.array(mask, dtype=np.float32) / 255.0
 
-# ====================== Decision layer ======================
+# ====================== Natural texture correction ======================
 
-def combine_scores(ela_mean, hf_ratio, noise_incons_score):
+def natural_texture_correction(pil_img: Image.Image):
     """
-    Weighted aggregation -> 'manipulated' confidence in [0,1].
-    Tuned to reduce false positives from naturally sharp clothing/jewelry.
+    Down-weight suspicion for clean studio portraits with smooth gradients.
+    Returns factor in [0.7, 1.0]; lower => more likely real.
     """
-    w1, w2, w3 = 0.30, 0.45, 0.25
+    gray = np.array(pil_img.convert("L"), dtype=np.float32) / 255.0
+    grad_x = cv2.Sobel(gray, cv2.CV_32F, 1, 0, ksize=3)
+    grad_y = cv2.Sobel(gray, cv2.CV_32F, 0, 1, ksize=3)
+    edge_strength = np.mean(np.sqrt(grad_x**2 + grad_y**2))
+    flatness = np.std(gray)
+    ratio = edge_strength / (flatness + 1e-6)       # small -> smooth/realistic
+    corr = 1.0 - np.clip((0.15 - ratio) * 2.5, 0, 0.3)
+    return float(np.clip(corr, 0.7, 1.0))
+
+# ====================== Decision layer ======================
+
+def combine_scores(ela_mean, hf_ratio, noise_incons_score, texture_corr=1.0):
+    # Balanced, with stricter cutoff to curb false positives on real portraits
+    w1, w2, w3 = 0.30, 0.40, 0.30
     s_ela = np.clip(ela_mean * 3.0, 0, 1)
-    s_hf  = np.clip((hf_ratio - 0.62) / 0.23, 0, 1)
+    s_hf  = np.clip((hf_ratio - 0.65) / 0.25, 0, 1)
     s_noi = np.clip(noise_incons_score, 0, 1)
-    suspect = float(w1 * s_ela + w2 * s_hf + w3 * s_noi)
-    label = "Likely Manipulated" if suspect >= 0.55 else "Likely Authentic"
+    suspect = float((w1*s_ela + w2*s_hf + w3*s_noi) * texture_corr)
+    label = "Likely Manipulated" if suspect >= 0.65 else "Likely Authentic"
     return label, suspect
 
 # ====================== Gradio handler ======================
@@ -156,23 +147,24 @@ def analyze_simple(pil_img: Image.Image):
     if pil_img is None:
         return "Upload an image."
 
-    # 1) Face crop + normalize size
+    # 1) Face crop + normalize
     pil_img = crop_face(pil_img)
     pil_img = pil_img.convert("RGB").resize((512, 512))
 
-    # 2) Build an oval face mask to ignore clothes/jewelry/background
-    oval = face_oval_mask(pil_img, shrink=0.88)
+    # 2) Face-only oval mask to ignore hair/neck/jewelry/background
+    oval = face_oval_mask(pil_img, shrink=0.80)
 
     # 3) Features
     ela_peak, ela_avg = ela_sweep_mean(pil_img)
-    # soften ELA if image recompresses extremely cleanly
     ela_mean = ela_peak * (0.85 if ela_avg < 0.06 else 1.0)
 
     _, hf_ratio  = fft_high_freq_ratio(pil_img, mask=oval)
     _, noi_score = noise_inconsistency(pil_img, mask=oval)
 
-    # 4) Decision
-    label, conf = combine_scores(ela_mean, hf_ratio, noi_score)
+    # 4) Natural texture correction + decision
+    texture_corr = natural_texture_correction(pil_img)
+    label, conf = combine_scores(ela_mean, hf_ratio, noi_score, texture_corr)
+
     return f"Deepfake likelihood: {conf*100:.1f}% — {label}"
 
 # ====================== UI ======================