crop footer

trufor_runner.py

@@ -7,7 +7,7 @@ import subprocess
 import tempfile
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Dict, Optional
+from typing import Dict, Optional, Tuple
 
 import numpy as np
 from PIL import Image
@@ -136,10 +136,17 @@ class TruForEngine:
         if image is None:
             raise TruForUnavailableError("No image supplied to TruFor inference.")
 
+        prepared_image, cropped = self._strip_gps_overlay(image)
+        if cropped:
+            LOGGER.debug(
+                "Cropping %d px GPS overlay before TruFor inference.",
+                image.height - prepared_image.height,
+            )
+
         if self.backend == "docker":
-            return self._infer_docker(image)
+            return self._infer_docker(prepared_image)
         if self.backend == "native":
-            return self._infer_native(image)
+            return self._infer_native(prepared_image)
 
         raise TruForUnavailableError("TruFor backend not configured.")
 
@@ -267,3 +274,123 @@ class TruForEngine:
 
         heat_img = Image.fromarray(heat, mode="RGB").resize(base_rgb.size, Image.BILINEAR)
         return Image.blend(base_rgb, heat_img, alpha)
+
+    @staticmethod
+    def _strip_gps_overlay(image: Image.Image) -> Tuple[Image.Image, bool]:
+        gray = np.asarray(image.convert("L"), dtype=np.uint8)
+        hsv = np.asarray(image.convert("HSV"), dtype=np.uint8)
+        hue = hsv[..., 0] / 255.0
+        sat = hsv[..., 1] / 255.0
+        val = hsv[..., 2] / 255.0
+        height, width = gray.shape
+        min_overlay = max(int(height * 0.08), 40)
+        max_overlay = max(int(height * 0.45), min_overlay + 1)
+        if height <= min_overlay:
+            return image, False
+        start_row = height - min_overlay
+        stop_row = max(height - max_overlay, 1)
+
+        row_means = gray.mean(axis=1)
+        sat_means = sat.mean(axis=1)
+        blue_mask = (hue >= 0.5) & (hue <= 0.75) & (sat >= 0.25) & (val <= 0.95)
+        yellow_mask = (hue >= 0.08) & (hue <= 0.18) & (sat >= 0.35) & (val >= 0.45)
+        white_mask = (val >= 0.87) & (sat <= 0.28)
+        dark_mask = val <= 0.28
+
+        overlay_mask = blue_mask | yellow_mask | white_mask | dark_mask
+        overlay_ratio_rows = overlay_mask.mean(axis=1)
+
+        boundary = None
+        best_score = 0.0
+
+        # First, try to detect a long contiguous overlay band using hysteresis on coverage.
+        high_ratio = 0.52
+        low_ratio = 0.36
+        run_len = 0
+        run_top = height
+        for row in range(height - 1, stop_row - 1, -1):
+            ratio = overlay_ratio_rows[row]
+            if ratio >= high_ratio or (run_len > 0 and ratio >= low_ratio):
+                run_len += 1
+                run_top = row
+                if run_len >= max_overlay:
+                    break
+            elif run_len > 0:
+                if run_len >= min_overlay:
+                    break
+                run_len = 0
+                run_top = height
+            elif height - row >= max_overlay:
+                break
+
+        if run_len >= min_overlay:
+            boundary_candidate = run_top
+            overlay_consistency = overlay_ratio_rows[boundary_candidate:height].mean()
+            boundary_strength = abs(row_means[boundary_candidate - 1] - row_means[boundary_candidate]) if boundary_candidate > 0 else abs(row_means[boundary_candidate] - row_means[min(boundary_candidate + 1, height - 1)])
+
+            if overlay_consistency >= 0.45 and boundary_strength >= 4.0:
+                overlay_height = height - boundary_candidate
+                margin = min(max(int(overlay_height * 0.25), 18), boundary_candidate)
+                crop_row = max(boundary_candidate - margin, 0)
+                cropped_image = image.crop((0, 0, width, crop_row))
+                return cropped_image, True
+
+        # Detect GPS Map Camera overlay at the bottom and crop it out if present.
+        for row in range(start_row, stop_row - 1, -1):
+            overlay_height = height - row
+            if overlay_height < min_overlay:
+                continue
+            if overlay_height > max_overlay:
+                break
+
+            overlay_hue = hue[row:height, :]
+            overlay_sat = sat[row:height, :]
+            overlay_val = val[row:height, :]
+
+            high_sat_ratio = float((overlay_sat > 0.3).mean())
+            dark_ratio = float((overlay_val < 0.3).mean())
+            bright_ratio = float((overlay_val > 0.88).mean())
+            colored_band_ratio = float(((overlay_sat > 0.32) & (overlay_val > 0.25) & (overlay_val < 0.85)).mean())
+            blue_ratio = float(((overlay_hue > 0.48) & (overlay_hue < 0.74) & (overlay_sat > 0.28)).mean())
+            yellow_ratio = float(((overlay_hue > 0.07) & (overlay_hue < 0.2) & (overlay_sat > 0.35) & (overlay_val > 0.45)).mean())
+
+            prev_mean = row_means[row - 1] if row > 0 else row_means[row]
+            boundary_strength = abs(prev_mean - row_means[row])
+            saturation_jump = sat_means[row - 1] - sat_means[row] if row > 0 else 0.0
+
+            score = 0.0
+            if high_sat_ratio > 0.38:
+                score += 0.8
+            if colored_band_ratio > 0.35:
+                score += 0.7
+            if blue_ratio > 0.22:
+                score += 0.8
+            if yellow_ratio > 0.12:
+                score += 0.5
+            if dark_ratio > 0.32:
+                score += 0.6
+            if bright_ratio > 0.07:
+                score += 0.5
+            if boundary_strength > 5.5:
+                score += 0.6
+            if saturation_jump < -0.05:
+                score += 0.4
+
+            edge_ratio = boundary_strength / max(row_means[row], 1.0)
+            if edge_ratio > 0.11:
+                score += 0.3
+            if overlay_ratio_rows[row:height].mean() > 0.42:
+                score += 0.3
+
+            if score > best_score:
+                best_score = score
+                boundary = row
+
+        if boundary is None or best_score < 1.6:
+            return image, False
+
+        overlay_height = height - boundary
+        margin = min(max(int(overlay_height * 0.25), 18), boundary)
+        crop_row = max(boundary - margin, 0)
+        cropped_image = image.crop((0, 0, width, crop_row))
+        return cropped_image, True