Upload agents/modality_detector.py with huggingface_hub

agents/modality_detector.py

@@ -1,300 +1,234 @@
 """
-FORENSIQ — Capture Modality Detector
+FORENSIQ — Capture Modality Detector v2
 
-Classifies images into capture modalities BEFORE forensic analysis.
-Each modality has known false-positive patterns that agents must account for.
+Classifies images BEFORE forensic analysis. Pure content-based detection
+that works even when Gradio strips metadata (format=None, no EXIF).
 
-Modalities:
-  DSLR          — Traditional camera, raw/JPEG from camera firmware
-  SMARTPHONE    — Standard smartphone photo (no portrait mode)
-  PORTRAIT_MODE — Smartphone portrait mode (computational bokeh)
-  SCREENSHOT    — Screen capture
-  MESSAGING     — Compressed via WhatsApp/Telegram/etc (stripped metadata, double JPEG)
-  SOCIAL_MEDIA  — Downloaded from Instagram/Facebook/Twitter (re-encoded, stripped)
-  UNKNOWN       — Cannot determine
+Key fix: detection works entirely from image pixel analysis, not metadata.
+Metadata signals are bonus evidence only.
 """
 
 import numpy as np
 from PIL import Image
 from scipy.ndimage import gaussian_filter, sobel
+from scipy.signal import convolve2d
 from dataclasses import dataclass
-from typing import Optional
 
 
 @dataclass
 class ModalityResult:
-    modality: str                # Primary modality classification
-    confidence: float            # 0-1
-    indicators: dict             # Evidence for the classification
-    score_adjustments: dict      # Per-test score multipliers (1.0 = no change, 0.0 = suppress)
+    modality: str
+    confidence: float
+    indicators: dict
+    score_adjustments: dict
 
 
 def detect_modality(img: Image.Image) -> ModalityResult:
-    """Detect capture modality from image properties."""
+    """Detect capture modality from image content and metadata."""
     indicators = {}
-    scores = {}  # modality -> evidence strength
+    scores = {}
     
     w, h = img.size
-    
-    # ── 1. Metadata analysis ──────────────────────────────────────────
-    try:
-        exif = img._getexif() or {}
-    except:
-        exif = {}
-    
-    from PIL.ExifTags import TAGS
-    decoded = {}
-    for tid, v in exif.items():
-        t = TAGS.get(tid, str(tid))
-        try:
-            decoded[t] = str(v)[:200]
-        except:
-            pass
-    
-    has_make = "Make" in decoded
-    has_model = "Model" in decoded
-    has_lens = "LensModel" in decoded or "LensInfo" in decoded
-    has_focal = "FocalLength" in decoded
-    has_software = "Software" in decoded
-    has_gps = "GPSInfo" in decoded
-    info = img.info or {}
-    source_format = getattr(img, 'format', None)
-    
-    cam_fields = sum([has_make, has_model, has_lens, has_focal])
-    indicators["exif_camera_fields"] = cam_fields
-    indicators["has_exif"] = bool(decoded)
-    indicators["format"] = source_format
-    
-    # Rich EXIF with lens info → DSLR
-    if cam_fields >= 3 and has_lens:
-        scores["DSLR"] = scores.get("DSLR", 0) + 0.4
-    
-    # Camera make is a phone brand
-    phone_brands = ["apple", "samsung", "google", "pixel", "huawei", "xiaomi", "oneplus",
-                    "oppo", "vivo", "realme", "motorola", "lg", "sony xperia", "nothing"]
-    make = decoded.get("Make", "").lower()
-    model = decoded.get("Model", "").lower()
-    if any(b in make or b in model for b in phone_brands):
-        scores["SMARTPHONE"] = scores.get("SMARTPHONE", 0) + 0.5
-        indicators["phone_brand"] = True
-    
-    # No EXIF at all → messaging/social or AI
-    if not decoded:
-        scores["MESSAGING"] = scores.get("MESSAGING", 0) + 0.3
-        scores["SOCIAL_MEDIA"] = scores.get("SOCIAL_MEDIA", 0) + 0.2
-        indicators["no_exif"] = True
-    
-    # ── 2. Resolution analysis ────────────────────────────────────────
-    mp = w * h / 1e6
-    indicators["megapixels"] = round(mp, 2)
-    
-    # Common messaging app resolutions (WhatsApp compresses to ~1600px max side)
-    max_side = max(w, h)
-    if max_side <= 1600 and mp < 3:
-        scores["MESSAGING"] = scores.get("MESSAGING", 0) + 0.25
-        indicators["low_res"] = True
-    
-    # Screenshot-like aspect ratios (phone screens)
-    ratio = max(w, h) / min(w, h)
-    if ratio > 1.9 and max_side > 1000:  # Tall phone screenshots
-        scores["SCREENSHOT"] = scores.get("SCREENSHOT", 0) + 0.3
-        indicators["tall_ratio"] = round(ratio, 2)
-    
-    # Standard phone ratios: 4:3 or 16:9
-    if abs(ratio - 4/3) < 0.05 or abs(ratio - 16/9) < 0.05:
-        scores["SMARTPHONE"] = scores.get("SMARTPHONE", 0) + 0.1
-    
-    # ── 3. Portrait mode detection (computational bokeh) ──────────────
     gray = np.array(img.convert("L")).astype(np.float64)
     
-    # Compute local sharpness map
+    # ═══ CONTENT-BASED DETECTION (works without metadata) ═════════════
+    
+    # ── Portrait mode detection ─────────────���─────────────────────────
+    # Core signal: bimodal sharpness distribution (sharp fg + uniform blur bg)
     lap = np.array([[0, 1, 0], [1, -4, 1], [0, 1, 0]], dtype=np.float64)
-    from scipy.signal import convolve2d
     laplacian = convolve2d(gray, lap, mode="same", boundary="symm")
-    sharpness = gaussian_filter(np.abs(laplacian), sigma=10)
+    sharpness = gaussian_filter(np.abs(laplacian), sigma=max(10, min(h, w) // 80))
+    
+    p25 = float(np.percentile(sharpness, 25))
+    p50 = float(np.percentile(sharpness, 50))
+    p75 = float(np.percentile(sharpness, 75))
+    p95 = float(np.percentile(sharpness, 95))
     
-    # Portrait mode signature: sharp foreground + uniformly blurred background
-    # with an ABRUPT transition between them (not gradual like real DoF)
-    sharp_thresh = np.percentile(sharpness, 75)
-    blur_thresh = np.percentile(sharpness, 25)
+    # Bimodality: large gap between p25 and p75
+    iqr = p75 - p25
+    bimodal_ratio = iqr / (p50 + 1e-9)
     
+    # Sharp region detection
+    sharp_thresh = p75
+    blur_thresh = p25
     sharp_region = sharpness > sharp_thresh
     blur_region = sharpness < blur_thresh
+    sharp_frac = float(np.mean(sharp_region))
+    blur_frac = float(np.mean(blur_region))
     
-    sharp_fraction = float(np.mean(sharp_region))
-    blur_fraction = float(np.mean(blur_region))
-    
-    # CRITICAL: Check absolute sharpness level, not just relative
-    # Real portrait photos have genuinely sharp foreground (textures, edges, pores)
-    # AI images are smooth everywhere — even the "sharp" region is soft
-    peak_sharpness = float(np.percentile(sharpness, 95))
-    median_sharpness = float(np.median(sharpness))
-    
-    # Check if blur is very uniform (computational vs optical)
-    blur_values = sharpness[blur_region] if np.any(blur_region) else np.array([0])
-    blur_uniformity = 1.0 - min(float(np.std(blur_values)) / (float(np.mean(blur_values)) + 1e-9), 1.0)
-    
-    # Check transition abruptness
-    sharpness_grad = np.hypot(
-        sobel(sharpness, axis=0),
-        sobel(sharpness, axis=1)
-    )
-    max_transition = float(np.percentile(sharpness_grad, 99))
-    mean_transition = float(np.mean(sharpness_grad))
-    transition_abruptness = max_transition / (mean_transition + 1e-9)
-    
-    indicators["sharp_fraction"] = round(sharp_fraction, 3)
-    indicators["blur_fraction"] = round(blur_fraction, 3)
-    indicators["blur_uniformity"] = round(blur_uniformity, 3)
-    indicators["transition_abruptness"] = round(transition_abruptness, 3)
-    indicators["peak_sharpness"] = round(peak_sharpness, 2)
-    indicators["median_sharpness"] = round(median_sharpness, 2)
-    
-    # Portrait mode detection — requires BOTH relative and absolute sharpness
-    # A real portrait photo has genuinely sharp foreground detail
-    # An AI-generated smooth image has low peak sharpness even if center > edges
-    has_genuine_detail = peak_sharpness > 10.0  # Real photos have Laplacian variance > 10
-    
-    portrait_signals = 0
-    if blur_fraction > 0.2 and sharp_fraction > 0.1 and has_genuine_detail:
-        portrait_signals += 1
-    if blur_uniformity > 0.5 and has_genuine_detail:
-        portrait_signals += 1
-    if transition_abruptness > 5 and has_genuine_detail:
-        portrait_signals += 1
-    
-    # Strong portrait mode: at least 2 of 3 signals AND genuine foreground detail
-    if portrait_signals >= 2 and has_genuine_detail:
-        scores["PORTRAIT_MODE"] = scores.get("PORTRAIT_MODE", 0) + 0.3 * portrait_signals
-        indicators["portrait_mode_signature"] = True
-    elif portrait_signals == 1 and blur_fraction > 0.25 and has_genuine_detail:
-        scores["PORTRAIT_MODE"] = scores.get("PORTRAIT_MODE", 0) + 0.2
-        indicators["portrait_mode_weak"] = True
-    
-    if not has_genuine_detail:
-        indicators["low_detail_image"] = True  # Smooth everywhere = possible AI
-    
-    # ── 4. Screenshot detection ───────────────────────────────────────
-    # Screenshots have: perfect pixel edges, UI elements, uniform background areas
-    edge_mag = np.hypot(sobel(gray, 0), sobel(gray, 1))
+    # Blur uniformity (computational blur is very uniform)
+    blur_vals = sharpness[blur_region] if np.any(blur_region) else np.array([1])
+    blur_uniformity = 1.0 - min(float(np.std(blur_vals)) / (float(np.mean(blur_vals)) + 1e-9), 1.0)
     
-    # Perfect horizontal/vertical edges (UI elements)
-    strong_edges = edge_mag > np.percentile(edge_mag, 95)
-    gx = sobel(gray, axis=1)
-    gy = sobel(gray, axis=0)
+    # Transition abruptness (computational segmentation = sharp boundary)
+    sharpness_grad = np.hypot(sobel(sharpness, 0), sobel(sharpness, 1))
+    max_grad = float(np.percentile(sharpness_grad, 99))
+    mean_grad = float(np.mean(sharpness_grad))
+    transition = max_grad / (mean_grad + 1e-9)
     
-    # Ratio of H/V edges to diagonal edges
-    h_edges = np.abs(gx) > np.abs(gy) * 3  # Strongly horizontal
-    v_edges = np.abs(gy) > np.abs(gx) * 3  # Strongly vertical
-    hv_ratio = float(np.sum(h_edges | v_edges)) / (float(np.sum(strong_edges)) + 1e-9)
+    # Absolute detail level (real photos have p95 > 5 even after heavy compression)
+    has_detail = p95 > 5.0
     
-    if hv_ratio > 0.6:
-        scores["SCREENSHOT"] = scores.get("SCREENSHOT", 0) + 0.3
-        indicators["hv_edge_ratio"] = round(hv_ratio, 3)
-    
-    # ── 5. Double JPEG / messaging detection ──────────────────────────
-    # Check for 8x8 block boundary artifacts (double JPEG)
+    indicators["p95_sharpness"] = round(p95, 2)
+    indicators["bimodal_ratio"] = round(bimodal_ratio, 3)
+    indicators["blur_uniformity"] = round(blur_uniformity, 3)
+    indicators["transition_abruptness"] = round(transition, 2)
+    indicators["has_detail"] = has_detail
+    
+    # Portrait mode scoring — multiple independent signals
+    portrait_score = 0.0
+    if has_detail and bimodal_ratio > 1.0:
+        portrait_score += 0.25  # Strong bimodal sharpness
+    if has_detail and blur_uniformity > 0.5:
+        portrait_score += 0.2   # Uniform blur region
+    if has_detail and transition > 4.0:
+        portrait_score += 0.2   # Abrupt sharp/blur boundary
+    if has_detail and blur_frac > 0.2 and sharp_frac > 0.1:
+        portrait_score += 0.15  # Distinct regions exist
+    
+    if portrait_score > 0.3:
+        scores["PORTRAIT_MODE"] = portrait_score
+        indicators["portrait_detected"] = True
+    
+    # ── Screenshot detection ──────────────────────────────────────────
+    edge_mag = np.hypot(sobel(gray, 0), sobel(gray, 1))
+    strong = edge_mag > np.percentile(edge_mag, 95)
+    gx = sobel(gray, axis=1); gy = sobel(gray, axis=0)
+    h_edges = np.abs(gx) > np.abs(gy) * 3
+    v_edges = np.abs(gy) > np.abs(gx) * 3
+    hv_ratio = float(np.sum(h_edges | v_edges)) / (float(np.sum(strong)) + 1e-9)
+    
+    ratio = max(w, h) / (min(w, h) + 1e-9)
+    if hv_ratio > 0.6 and ratio > 1.8:
+        scores["SCREENSHOT"] = 0.6
+        indicators["screenshot_detected"] = True
+    
+    # ── Double JPEG detection (messaging) ─────────────────────────────
     hc, wc = (gray.shape[0] // 8) * 8, (gray.shape[1] // 8) * 8
+    blockiness = 1.0
     if hc > 16 and wc > 16:
         g = gray[:hc, :wc]
         bd = [float(np.mean(np.abs(g[i, :] - g[i-1, :]))) for i in range(8, hc, 8)]
         it = [float(np.mean(np.abs(g[i, :] - g[i-1, :]))) for i in range(1, hc) if i % 8 != 0]
         if bd and it:
             blockiness = float(np.mean(bd)) / (float(np.mean(it)) + 1e-9)
-            if blockiness > 1.3:
-                scores["MESSAGING"] = scores.get("MESSAGING", 0) + 0.2
-                indicators["double_jpeg"] = round(blockiness, 3)
     
-    # ── 6. Determine primary modality ─────────────────────────────────
+    indicators["blockiness"] = round(blockiness, 3)
+    
+    # ═══ METADATA-BASED DETECTION (bonus signals) ═════════════════════
+    
+    try:
+        exif = img._getexif() or {}
+    except:
+        exif = {}
+    
+    from PIL.ExifTags import TAGS
+    decoded = {}
+    for tid, v in exif.items():
+        t = TAGS.get(tid, str(tid))
+        try: decoded[t] = str(v)[:200]
+        except: pass
+    
+    has_exif = bool(decoded)
+    indicators["has_exif"] = has_exif
+    indicators["format"] = getattr(img, 'format', None)
+    
+    # Phone brand in EXIF
+    phone_brands = ["apple", "samsung", "google", "pixel", "huawei", "xiaomi", "oneplus",
+                    "oppo", "vivo", "realme", "motorola", "lg", "nothing"]
+    make = decoded.get("Make", "").lower()
+    model = decoded.get("Model", "").lower()
+    is_phone = any(b in make or b in model for b in phone_brands)
+    
+    if is_phone:
+        scores["SMARTPHONE"] = scores.get("SMARTPHONE", 0) + 0.4
+        indicators["phone_brand"] = True
+    
+    # Rich EXIF with lens → DSLR
+    cam_fields = sum(["Make" in decoded, "Model" in decoded, 
+                      "LensModel" in decoded or "LensInfo" in decoded, "FocalLength" in decoded])
+    if cam_fields >= 3 and ("LensModel" in decoded or "LensInfo" in decoded):
+        scores["DSLR"] = scores.get("DSLR", 0) + 0.5
+    
+    # No EXIF + low res + double JPEG → messaging
+    max_side = max(w, h)
+    no_exif_low_res = not has_exif and max_side <= 1600
+    if no_exif_low_res:
+        scores["MESSAGING"] = scores.get("MESSAGING", 0) + 0.3
+        indicators["no_exif_low_res"] = True
+    if blockiness > 1.3:
+        scores["MESSAGING"] = scores.get("MESSAGING", 0) + 0.2
+        indicators["double_jpeg"] = True
+    
+    # ═══ DETERMINE MODALITY ═══════════════════════════════════════��═══
+    
     if not scores:
         modality = "UNKNOWN"
-        confidence = 0.2
+        conf = 0.2
     else:
         modality = max(scores, key=scores.get)
-        confidence = min(1.0, scores[modality])
+        conf = min(1.0, scores[modality])
     
-    # Override: portrait mode wins over messaging/smartphone when detected
-    if scores.get("PORTRAIT_MODE", 0) > 0.2:
+    # Portrait mode always wins when detected (it's the most specific modality)
+    if scores.get("PORTRAIT_MODE", 0) > 0.3:
         modality = "PORTRAIT_MODE"
-        confidence = min(1.0, scores["PORTRAIT_MODE"])
+        conf = min(1.0, scores["PORTRAIT_MODE"])
     
-    # SAFETY GUARD: If image has no genuine photographic detail (low peak sharpness),
-    # it's likely AI-generated, not a real camera photo. In this case, do NOT apply
-    # any modality suppression — let all forensic tests fire at full strength.
-    if indicators.get("low_detail_image", False):
+    # SAFETY GUARD: No detail = possible AI. Disable all suppression.
+    if not has_detail:
         modality = "UNKNOWN"
-        confidence = 0.2
-        indicators["modality_override"] = "Low-detail image — suppression disabled to avoid protecting AI content"
+        conf = 0.2
+        indicators["safety_override"] = "Low-detail image — suppression disabled"
+    
+    # ═══ BUILD ADJUSTMENTS ════════════════════════════════════════════
     
-    # ── 7. Build score adjustments ────────────────────────────────────
-    # Merge adjustments when multiple modalities detected
-    # (e.g., portrait mode photo sent via messaging app gets BOTH sets)
     adjustments = _get_modality_adjustments(modality)
     
-    # If messaging signals are present alongside portrait mode, merge messaging adjustments
-    if modality == "PORTRAIT_MODE" and scores.get("MESSAGING", 0) > 0.2:
-        messaging_adj = _get_modality_adjustments("MESSAGING")
-        for test_name, multiplier in messaging_adj.items():
-            if test_name not in adjustments:
-                adjustments[test_name] = multiplier
-            else:
-                # Take the more suppressive (lower) multiplier
-                adjustments[test_name] = min(adjustments[test_name], multiplier)
+    # Merge messaging adjustments when portrait + messaging both detected
+    if modality == "PORTRAIT_MODE" and scores.get("MESSAGING", 0) > 0.15:
+        msg_adj = _get_modality_adjustments("MESSAGING")
+        for k, v in msg_adj.items():
+            adjustments[k] = min(adjustments.get(k, 1.0), v)
         indicators["dual_modality"] = "PORTRAIT_MODE + MESSAGING"
     
-    return ModalityResult(
-        modality=modality,
-        confidence=round(confidence, 3),
-        indicators=indicators,
-        score_adjustments=adjustments,
-    )
+    indicators["modality_scores"] = {k: round(v, 3) for k, v in scores.items()}
+    
+    return ModalityResult(modality, round(conf, 3), indicators, adjustments)
 
 
 def _get_modality_adjustments(modality: str) -> dict:
-    """
-    Return per-test score multipliers for known false-positive patterns.
-    1.0 = no change, 0.0 = suppress entirely, 0.5 = halve the score.
-    """
-    
     if modality == "PORTRAIT_MODE":
         return {
-            # These tests false-positive on computational bokeh
-            "Autocorrelation Peak": 0.1,      # Bokeh creates periodic patterns
-            "Texture Repetition": 0.1,         # Bokeh is repetitive by design
-            "VAE Patch Boundaries": 0.2,       # Segmentation mask operates in blocks
-            "PRNU Uniformity": 0.15,           # Dual-region noise (sharp vs blur)
-            "Poisson-Gaussian Model": 0.3,     # Noise model breaks with synthetic blur
-            "DoF Consistency": 0.2,            # Abrupt transitions are EXPECTED
-            "Vignetting cos⁴θ": 0.3,          # Smartphones don't follow cos⁴θ
-            "HF Noise Structure": 0.3,         # Blur region has different noise
-            "Noise Spatial Frequency": 0.3,    # Same reason
-            "CFA Nyquist": 0.25,              # Computational processing destroys CFA traces entirely
-            # Spectral tests affected by computational photography
-            "Spectral Slope 1/f²": 0.5,       # Frequency-selective sharpening steepens slope
-            "Spectral Symmetry": 0.4,          # Depth-based processing creates asymmetry
-            "Phase Coherence": 0.4,            # Segmentation boundary = phase discontinuity
-            # Sensor tests affected by smartphone tone curves
-            "Pixel Response Linearity": 0.3,   # Aggressive HDR/tone mapping = expected non-linearity
-            # Sensor tests affected by computational processing
-            "Demosaic Interpolation": 0.4,     # Heavy ISP processing removes demosaic traces
-            "Saturation Clipping": 0.4,        # Computational HDR avoids clipping artificially
+            "Autocorrelation Peak": 0.1,
+            "Texture Repetition": 0.1,
+            "VAE Patch Boundaries": 0.2,
+            "PRNU Uniformity": 0.15,
+            "Poisson-Gaussian Model": 0.3,
+            "DoF Consistency": 0.2,
+            "Vignetting cos⁴θ": 0.3,
+            "HF Noise Structure": 0.3,
+            "Noise Spatial Frequency": 0.3,
+            "CFA Nyquist": 0.25,
+            "Spectral Slope 1/f²": 0.5,
+            "Spectral Symmetry": 0.4,
+            "Phase Coherence": 0.4,
+            "Pixel Response Linearity": 0.3,
+            "Demosaic Interpolation": 0.4,
+            "Saturation Clipping": 0.4,
         }
-    
     elif modality == "MESSAGING":
         return {
-            # These tests false-positive on messaging compression
-            "EXIF Completeness": 0.15,         # WhatsApp strips ALL EXIF — this is normal
-            "Compression Ghosts": 0.2,         # Double JPEG is expected
-            "ICC Color Profile": 0.2,          # Stripped by messaging apps
-            "Maker Note": 0.2,                 # Stripped
-            "Thumbnail Check": 0.2,            # Stripped
-            "Software Detection": 0.2,         # Stripped
-            "JPEG Quantization": 0.3,          # Re-encoded with generic tables
-            "CFA Nyquist": 0.5,               # Re-encoding destroys CFA traces
-            "Watermark Detection": 0.2,        # JPEG grid creates spectral peaks — not a real watermark
-            "Demosaic Interpolation": 0.5,     # Re-encoding smooths demosaic
+            "EXIF Completeness": 0.15,
+            "Compression Ghosts": 0.2,
+            "ICC Color Profile": 0.2,
+            "Maker Note": 0.2,
+            "Thumbnail Check": 0.2,
+            "Software Detection": 0.2,
+            "JPEG Quantization": 0.3,
+            "CFA Nyquist": 0.5,
+            "Watermark Detection": 0.2,
+            "Demosaic Interpolation": 0.5,
         }
-    
     elif modality == "SOCIAL_MEDIA":
         return {
             "EXIF Completeness": 0.2,
@@ -303,36 +237,22 @@ def _get_modality_adjustments(modality: str) -> dict:
             "Maker Note": 0.2,
             "Thumbnail Check": 0.3,
         }
-    
     elif modality == "SCREENSHOT":
         return {
-            # Screenshots are NOT photos — most optical/sensor tests are meaningless
-            "Vignetting cos⁴θ": 0.1,
-            "Vignetting Symmetry": 0.1,
-            "Lens Distortion": 0.1,
-            "Field Curvature": 0.1,
-            "CA Magnitude": 0.1,
-            "CA Radial Gradient": 0.1,
-            "Lateral CA": 0.1,
-            "Purple Fringing": 0.1,
-            "Bokeh Shape": 0.1,
-            "PRNU Uniformity": 0.1,
-            "Bayer CFA Pattern": 0.1,
-            "CFA Nyquist": 0.1,
-            "Hot/Dead Pixels": 0.1,
-            "Noise Autocorrelation": 0.1,
-            "Demosaic Interpolation": 0.1,
+            "Vignetting cos⁴θ": 0.1, "Vignetting Symmetry": 0.1,
+            "Lens Distortion": 0.1, "Field Curvature": 0.1,
+            "CA Magnitude": 0.1, "CA Radial Gradient": 0.1, "Lateral CA": 0.1,
+            "Purple Fringing": 0.1, "Bokeh Shape": 0.1,
+            "PRNU Uniformity": 0.1, "Bayer CFA Pattern": 0.1, "CFA Nyquist": 0.1,
+            "Hot/Dead Pixels": 0.1, "Noise Autocorrelation": 0.1, "Demosaic Interpolation": 0.1,
         }
-    
     elif modality == "SMARTPHONE":
         return {
-            # Smartphones use computational photography — mild suppression
-            "Vignetting cos⁴θ": 0.5,          # Computational correction
-            "CFA Nyquist": 0.7,               # Heavy ISP processing
-            "Poisson-Gaussian Model": 0.7,     # Noise reduction
-            "Pixel Response Linearity": 0.4,   # HDR/tone mapping = non-linear
-            "Spectral Slope 1/f²": 0.7,       # Sharpening affects slope
+            "Vignetting cos⁴θ": 0.5,
+            "CFA Nyquist": 0.7,
+            "Poisson-Gaussian Model": 0.7,
+            "Pixel Response Linearity": 0.4,
+            "Spectral Slope 1/f²": 0.7,
         }
-    
-    else:  # DSLR or UNKNOWN
-        return {}  # No adjustments — full scoring
+    else:
+        return {}