multi

app.py

@@ -1,1003 +1,966 @@
-# app.py
-import gradio as gr
-import torch
-import torch.nn as nn
-from torchvision import models, transforms
-from PIL import Image
-import numpy as np
-import pickle
-import os
-import cv2
+# # app.py
+# import gradio as gr
+# import torch
+# import torch.nn as nn
+# from torchvision import models, transforms
+# from PIL import Image
+# import numpy as np
+# import pickle
+# import os
+# import cv2
+
+# # class EnginePartDetector:
+# #     def __init__(self):
+# #         self.model = models.resnet50(weights='IMAGENET1K_V1')
+# #         self.model = nn.Sequential(*list(self.model.children())[:-1])
+# #         self.model.eval()
+        
+# #         self.transform = transforms.Compose([
+# #             transforms.Resize((224, 224)),
+# #             transforms.ToTensor(),
+# #             transforms.Normalize(
+# #                 mean=[0.485, 0.456, 0.406],
+# #                 std=[0.229, 0.224, 0.225]
+# #             )
+# #         ])
+        
+# #         self.templates = {}
+# #         self.load_templates()
+    
+# #     def extract_features(self, image):
+# #         if isinstance(image, np.ndarray):
+# #             image = Image.fromarray(image)
+        
+# #         img_tensor = self.transform(image).unsqueeze(0)
+        
+# #         with torch.no_grad():
+# #             features = self.model(img_tensor)
+# #             features = features.squeeze().numpy()
+        
+# #         return features
 
 # class EnginePartDetector:
-#     def __init__(self):
+#     def __init__(
+#         self,
+#         clahe_clip_limit: float = 9.9,
+#         clahe_tile_grid: tuple = (8, 8),
+#     ):
+#         # ── ResNet-50 backbone (feature extractor only) ──────────────────
 #         self.model = models.resnet50(weights='IMAGENET1K_V1')
 #         self.model = nn.Sequential(*list(self.model.children())[:-1])
 #         self.model.eval()
-        
+
+#         # ── CLAHE (OpenCV) — applied BEFORE the torch transform ──────────
+#         # Operates on grayscale to recover shadow-suppressed edges
+#         # (e.g. missing bearing saddle arcs), then merged back to RGB
+#         # so the 3-channel ResNet pipeline is unaffected.
+#         self.clahe = cv2.createCLAHE(
+#             clipLimit=clahe_clip_limit,
+#             tileGridSize=clahe_tile_grid,
+#         )
+
+#         # ── ResNet normalisation transform (unchanged) ───────────────────
 #         self.transform = transforms.Compose([
 #             transforms.Resize((224, 224)),
 #             transforms.ToTensor(),
 #             transforms.Normalize(
 #                 mean=[0.485, 0.456, 0.406],
-#                 std=[0.229, 0.224, 0.225]
+#                 std=[0.229, 0.224, 0.225],
 #             )
 #         ])
-        
+
 #         self.templates = {}
 #         self.load_templates()
-    
-#     def extract_features(self, image):
-#         if isinstance(image, np.ndarray):
-#             image = Image.fromarray(image)
-        
-#         img_tensor = self.transform(image).unsqueeze(0)
-        
-#         with torch.no_grad():
-#             features = self.model(img_tensor)
-#             features = features.squeeze().numpy()
-        
-#         return features
-
-class EnginePartDetector:
-    def __init__(
-        self,
-        clahe_clip_limit: float = 9.9,
-        clahe_tile_grid: tuple = (8, 8),
-    ):
-        # ── ResNet-50 backbone (feature extractor only) ──────────────────
-        self.model = models.resnet50(weights='IMAGENET1K_V1')
-        self.model = nn.Sequential(*list(self.model.children())[:-1])
-        self.model.eval()
-
-        # ── CLAHE (OpenCV) — applied BEFORE the torch transform ──────────
-        # Operates on grayscale to recover shadow-suppressed edges
-        # (e.g. missing bearing saddle arcs), then merged back to RGB
-        # so the 3-channel ResNet pipeline is unaffected.
-        self.clahe = cv2.createCLAHE(
-            clipLimit=clahe_clip_limit,
-            tileGridSize=clahe_tile_grid,
-        )
-
-        # ── ResNet normalisation transform (unchanged) ───────────────────
-        self.transform = transforms.Compose([
-            transforms.Resize((224, 224)),
-            transforms.ToTensor(),
-            transforms.Normalize(
-                mean=[0.485, 0.456, 0.406],
-                std=[0.229, 0.224, 0.225],
-            )
-        ])
 
-        self.templates = {}
-        self.load_templates()
+#     # ── CLAHE preprocessing ───────────────────────────────────────────────
 
-    # ── CLAHE preprocessing ───────────────────────────────────────────────
-
-    def apply_clahe(self, image: np.ndarray) -> np.ndarray:
+#     def apply_clahe(self, image: np.ndarray) -> np.ndarray:
         
-        # Convert RGB (PIL/numpy) → BGR for OpenCV
-        bgr = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+#         # Convert RGB (PIL/numpy) → BGR for OpenCV
+#         bgr = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
 
-        # BGR → LAB
-        lab = cv2.cvtColor(bgr, cv2.COLOR_BGR2LAB)
+#         # BGR → LAB
+#         lab = cv2.cvtColor(bgr, cv2.COLOR_BGR2LAB)
 
-        # Split channels; apply CLAHE only to L (luminance)
-        l_channel, a_channel, b_channel = cv2.split(lab)
-        l_enhanced = self.clahe.apply(l_channel)
+#         # Split channels; apply CLAHE only to L (luminance)
+#         l_channel, a_channel, b_channel = cv2.split(lab)
+#         l_enhanced = self.clahe.apply(l_channel)
 
-        # Merge enhanced L back with untouched A and B
-        lab_enhanced = cv2.merge([l_enhanced, a_channel, b_channel])
+#         # Merge enhanced L back with untouched A and B
+#         lab_enhanced = cv2.merge([l_enhanced, a_channel, b_channel])
 
-        # LAB → BGR → RGB
-        bgr_enhanced = cv2.cvtColor(lab_enhanced, cv2.COLOR_LAB2BGR)
-        rgb_enhanced = cv2.cvtColor(bgr_enhanced, cv2.COLOR_BGR2RGB)
+#         # LAB → BGR → RGB
+#         bgr_enhanced = cv2.cvtColor(lab_enhanced, cv2.COLOR_LAB2BGR)
+#         rgb_enhanced = cv2.cvtColor(bgr_enhanced, cv2.COLOR_BGR2RGB)
 
-        return rgb_enhanced  # uint8 numpy array, same shape as input
+#         return rgb_enhanced  # uint8 numpy array, same shape as input
 
-    # ── Feature extraction ────────────────────────────────────────────────
+#     # ── Feature extraction ────────────────────────────────────────────────
 
-    def extract_features(self, image) -> np.ndarray:
+#     def extract_features(self, image) -> np.ndarray:
        
-        # 1. Normalise input to numpy uint8 RGB
-        if isinstance(image, Image.Image):
-            image = np.array(image.convert("RGB"))
-        elif isinstance(image, np.ndarray) and image.dtype != np.uint8:
-            image = image.astype(np.uint8)
+#         # 1. Normalise input to numpy uint8 RGB
+#         if isinstance(image, Image.Image):
+#             image = np.array(image.convert("RGB"))
+#         elif isinstance(image, np.ndarray) and image.dtype != np.uint8:
+#             image = image.astype(np.uint8)
 
-        # 2. CLAHE — recover shadow-suppressed structural edges
-        image = self.apply_clahe(image)
+#         # 2. CLAHE — recover shadow-suppressed structural edges
+#         image = self.apply_clahe(image)
 
-        # 3. Mild Gaussian blur — reduces high-freq metallic sheen noise
-        #    that CLAHE can amplify; kernel (3,3) is intentionally light
-        #    so real surface-defect texture is preserved
-        image = cv2.GaussianBlur(image, (3, 3), 0)
+#         # 3. Mild Gaussian blur — reduces high-freq metallic sheen noise
+#         #    that CLAHE can amplify; kernel (3,3) is intentionally light
+#         #    so real surface-defect texture is preserved
+#         image = cv2.GaussianBlur(image, (3, 3), 0)
 
-        # 4. Convert back to PIL for torchvision transforms
-        image_pil = Image.fromarray(image)
+#         # 4. Convert back to PIL for torchvision transforms
+#         image_pil = Image.fromarray(image)
 
-        # 5. ResNet transform → tensor
-        img_tensor = self.transform(image_pil).unsqueeze(0)
+#         # 5. ResNet transform → tensor
+#         img_tensor = self.transform(image_pil).unsqueeze(0)
 
-        # 6. Forward pass (no grad needed — inference only)
-        with torch.no_grad():
-            features = self.model(img_tensor)
-            features = features.squeeze().numpy()
+#         # 6. Forward pass (no grad needed — inference only)
+#         with torch.no_grad():
+#             features = self.model(img_tensor)
+#             features = features.squeeze().numpy()
 
-        return features 
+#         return features 
     
-    def cosine_similarity(self, feat1, feat2):
-        return np.dot(feat1, feat2) / (np.linalg.norm(feat1) * np.linalg.norm(feat2))
+#     def cosine_similarity(self, feat1, feat2):
+#         return np.dot(feat1, feat2) / (np.linalg.norm(feat1) * np.linalg.norm(feat2))
     
-    def save_template(self, image, part_name):
-        if image is None or not part_name:
-            return "Please provide both image and part name"
+#     def save_template(self, image, part_name):
+#         if image is None or not part_name:
+#             return "Please provide both image and part name"
         
-        features = self.extract_features(image)
-        self.templates[part_name] = features
+#         features = self.extract_features(image)
+#         self.templates[part_name] = features
         
-        with open('templates.pkl', 'wb') as f:
-            pickle.dump(self.templates, f)
+#         with open('templates.pkl', 'wb') as f:
+#             pickle.dump(self.templates, f)
         
-        return f"✅ Template '{part_name}' saved successfully!"
+#         return f"✅ Template '{part_name}' saved successfully!"
     
-    def load_templates(self):
-        if os.path.exists('templates.pkl'):
-            try:
-                with open('templates.pkl', 'rb') as f:
-                    self.templates = pickle.load(f)
-            except:
-                self.templates = {}
+#     def load_templates(self):
+#         if os.path.exists('templates.pkl'):
+#             try:
+#                 with open('templates.pkl', 'rb') as f:
+#                     self.templates = pickle.load(f)
+#             except:
+#                 self.templates = {}
     
-    def match_part(self, image, threshold=0.7):
-        if image is None:
-            return "Please provide an image", None
+#     def match_part(self, image, threshold=0.7):
+#         if image is None:
+#             return "Please provide an image", None
         
-        if not self.templates:
-            return "⚠️ No templates available. Please add templates first.", None
+#         if not self.templates:
+#             return "⚠️ No templates available. Please add templates first.", None
         
-        query_features = self.extract_features(image)
+#         query_features = self.extract_features(image)
         
-        results = []
-        for part_name, template_features in self.templates.items():
-            similarity = self.cosine_similarity(query_features, template_features)
-            results.append((part_name, similarity))
+#         results = []
+#         for part_name, template_features in self.templates.items():
+#             similarity = self.cosine_similarity(query_features, template_features)
+#             results.append((part_name, similarity))
         
-        results.sort(key=lambda x: x[1], reverse=True)
+#         results.sort(key=lambda x: x[1], reverse=True)
         
-        best_match = results[0]
-        output_text = f"🔍 **Best Match**: {best_match[0]}\n"
-        output_text += f"📊 **Confidence**: {best_match[1]:.2%}\n\n"
+#         best_match = results[0]
+#         output_text = f"🔍 **Best Match**: {best_match[0]}\n"
+#         output_text += f"📊 **Confidence**: {best_match[1]:.2%}\n\n"
         
-        if best_match[1] >= threshold:
-            output_text += "✅ **Status**: MATCHED\n\n"
-        else:
-            output_text += "❌ **Status**: NO MATCH (below threshold)\n\n"
+#         if best_match[1] >= threshold:
+#             output_text += "✅ **Status**: MATCHED\n\n"
+#         else:
+#             output_text += "❌ **Status**: NO MATCH (below threshold)\n\n"
         
-        output_text += "**All Results:**\n"
-        for part, sim in results:
-            output_text += f"- {part}: {sim:.2%}\n"
+#         output_text += "**All Results:**\n"
+#         for part, sim in results:
+#             output_text += f"- {part}: {sim:.2%}\n"
         
-        matched_label = best_match[0] if best_match[1] >= threshold else None
-        return output_text, matched_label
+#         matched_label = best_match[0] if best_match[1] >= threshold else None
+#         return output_text, matched_label
 
-detector = EnginePartDetector()
+# detector = EnginePartDetector()
 
-def add_template(image, part_name):
-    return detector.save_template(image, part_name)
+# def add_template(image, part_name):
+#     return detector.save_template(image, part_name)
 
-def detect_part(image, threshold):
-    return detector.match_part(image, threshold)
+# def detect_part(image, threshold):
+#     return detector.match_part(image, threshold)
 
-def list_templates():
-    if not detector.templates:
-        return "No templates saved yet"
-    return "\n".join([f"- {name}" for name in detector.templates.keys()])
+# def list_templates():
+#     if not detector.templates:
+#         return "No templates saved yet"
+#     return "\n".join([f"- {name}" for name in detector.templates.keys()])
 
-with gr.Blocks(title="Engine Part Detection System") as demo:
-    gr.Markdown("""
-    # 🔧 Engine Part Detection System
-    ### Using ResNet50 Feature Extraction & Template Matching
+# with gr.Blocks(title="Engine Part Detection System") as demo:
+#     gr.Markdown("""
+#     # 🔧 Engine Part Detection System
+#     ### Using ResNet50 Feature Extraction & Template Matching
     
-    **How to use:**
-    1. **Add Templates**: Upload reference images of engine parts
-    2. **Detect Parts**: Upload/capture images to identify parts
-    """)
+#     **How to use:**
+#     1. **Add Templates**: Upload reference images of engine parts
+#     2. **Detect Parts**: Upload/capture images to identify parts
+#     """)
     
-    with gr.Tab("🔍 Detect Part"):
-        with gr.Row():
-            with gr.Column():
-                detect_input = gr.Image(sources=["upload", "webcam"], type="numpy")
-                threshold_slider = gr.Slider(0.5, 0.95, value=0.7, label="Similarity Threshold")
-                detect_btn = gr.Button("Detect Part", variant="primary")
-            with gr.Column():
-                detect_output = gr.Textbox(label="Detection Results", lines=10)
-                match_label = gr.Label(label="Matched Part")
+#     with gr.Tab("🔍 Detect Part"):
+#         with gr.Row():
+#             with gr.Column():
+#                 detect_input = gr.Image(sources=["upload", "webcam"], type="numpy")
+#                 threshold_slider = gr.Slider(0.5, 0.95, value=0.7, label="Similarity Threshold")
+#                 detect_btn = gr.Button("Detect Part", variant="primary")
+#             with gr.Column():
+#                 detect_output = gr.Textbox(label="Detection Results", lines=10)
+#                 match_label = gr.Label(label="Matched Part")
         
-        detect_btn.click(
-            fn=detect_part,
-            inputs=[detect_input, threshold_slider],
-            outputs=[detect_output, match_label],
-            api_name="detect"
-        )
+#         detect_btn.click(
+#             fn=detect_part,
+#             inputs=[detect_input, threshold_slider],
+#             outputs=[detect_output, match_label],
+#             api_name="detect"
+#         )
     
-    with gr.Tab("➕ Add Template"):
-        with gr.Row():
-            with gr.Column():
-                template_input = gr.Image(sources=["upload"], type="numpy")
-                part_name_input = gr.Textbox(label="Part Name (e.g., 'spark_plug', 'piston')")
-                add_btn = gr.Button("Save Template", variant="primary")
-            with gr.Column():
-                add_output = gr.Textbox(label="Status")
+#     with gr.Tab("➕ Add Template"):
+#         with gr.Row():
+#             with gr.Column():
+#                 template_input = gr.Image(sources=["upload"], type="numpy")
+#                 part_name_input = gr.Textbox(label="Part Name (e.g., 'spark_plug', 'piston')")
+#                 add_btn = gr.Button("Save Template", variant="primary")
+#             with gr.Column():
+#                 add_output = gr.Textbox(label="Status")
         
-        add_btn.click(
-            fn=add_template,
-            inputs=[template_input, part_name_input],
-            outputs=add_output,
-            api_name="add_template"
-        )
+#         add_btn.click(
+#             fn=add_template,
+#             inputs=[template_input, part_name_input],
+#             outputs=add_output,
+#             api_name="add_template"
+#         )
     
-    with gr.Tab("📋 View Templates"):
-        template_list = gr.Textbox(label="Saved Templates", lines=10)
-        refresh_btn = gr.Button("Refresh List")
-        refresh_btn.click(
-            fn=list_templates,
-            outputs=template_list,
-            api_name="list_templates"
+#     with gr.Tab("📋 View Templates"):
+#         template_list = gr.Textbox(label="Saved Templates", lines=10)
+#         refresh_btn = gr.Button("Refresh List")
+#         refresh_btn.click(
+#             fn=list_templates,
+#             outputs=template_list,
+#             api_name="list_templates"
+#         )
+#         demo.load(fn=list_templates, outputs=template_list)
+
+# if __name__ == "__main__":
+#     demo.launch()
+
+"""
+Production-Grade Engine Part Detection System
+Multi-Layer Architecture:
+  Layer 1 — Geometric Detection   : HoughCircles → bolt-hole centers → line fitting → saddle crop
+  Layer 2 — Feature Extraction    : CLAHE pre-processing → ResNet-50 deep features
+  Layer 3 — Template Matching     : Cosine-similarity with confidence scoring
+  Layer 4 — UI / Orchestration    : Gradio interface tying all layers together
+
+Author: Senior CV Engineer
+"""
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Standard & third-party imports
+# ──────────────────────────────────────────────────────────────────────────────
+import os
+import pickle
+import logging
+from dataclasses import dataclass, field
+from typing import Optional, Tuple, List
+
+import cv2
+import gradio as gr
+import numpy as np
+import torch
+import torch.nn as nn
+from PIL import Image
+from scipy import stats
+from torchvision import models, transforms
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Logging
+# ──────────────────────────────────────────────────────────────────────────────
+logging.basicConfig(
+    level=logging.INFO,
+    format="[%(levelname)s] %(name)s — %(message)s",
+)
+logger = logging.getLogger("EnginePartDetector")
+
+
+# ���─────────────────────────────────────────────────────────────────────────────
+# Config dataclass — all tunable hyperparameters in one place
+# ──────────────────────────────────────────────────────────────────────────────
+@dataclass
+class DetectorConfig:
+    # ── Hough circle params ──────────────────────────────────────────
+    hough_dp: float = 1.2          # Inverse resolution ratio
+    hough_param1: int = 60         # Canny high threshold
+    hough_param2: int = 25         # Accumulator threshold (lower = more detections)
+    bolt_min_radius: int = 8       # px — smallest bolt-hole radius expected
+    bolt_max_radius: int = 40      # px — largest bolt-hole radius expected
+    min_dist_factor: float = 0.06  # minDist = factor × min(H, W)
+
+    # ── Row-clustering params ────────────────────────────────────────
+    # Y-axis gap between two circle rows must exceed this fraction of image height
+    row_separation_min: float = 0.05
+
+    # ── Crop padding ─────────────────────────────────────────────────
+    crop_padding_px: int = 12      # Extra pixels above top-line & below bottom-line
+
+    # ── CLAHE params ─────────────────────────────────────────────────
+    clahe_clip_limit: float = 9.9
+    clahe_tile_grid: Tuple[int, int] = field(default_factory=lambda: (8, 8))
+
+    # ── Template store ───────────────────────────────────────────────
+    templates_path: str = "templates.pkl"
+
+    # ── Detection threshold ──────────────────────────────────────────
+    default_threshold: float = 0.70
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# LAYER 1 — SaddleRegionExtractor
+# ──────────────────────────────────────────────────────────────────────────────
+class SaddleRegionExtractor:
+    """
+    Geometric detection layer.
+
+    Pipeline
+    --------
+    1. Pre-process (CLAHE + bilateral filter) for robust edge contrast
+    2. HoughCircles to find all circles in the image
+    3. Filter to bolt-hole size range
+    4. K-means (k=2) on Y-coordinate → top row / bottom row
+    5. Robust linear regression (via scipy) through each row's centers
+    6. Per-column masking to crop exactly between the two fitted lines
+    """
+
+    def __init__(self, cfg: DetectorConfig):
+        self.cfg = cfg
+        self._clahe = cv2.createCLAHE(
+            clipLimit=cfg.clahe_clip_limit,
+            tileGridSize=cfg.clahe_tile_grid,
         )
-        demo.load(fn=list_templates, outputs=template_list)
 
-if __name__ == "__main__":
-    demo.launch()
+    # ── Pre-processing ────────────────────────────────────────────────────────
 
+    def _preprocess(self, rgb: np.ndarray) -> np.ndarray:
+        """Enhance contrast and reduce noise for circle detection."""
+        bgr = cv2.cvtColor(rgb, cv2.COLOR_RGB2BGR)
+        lab = cv2.cvtColor(bgr, cv2.COLOR_BGR2LAB)
+        l, a, b = cv2.split(lab)
+        l = self._clahe.apply(l)
+        gray = cv2.cvtColor(cv2.cvtColor(cv2.merge([l, a, b]), cv2.COLOR_LAB2BGR), cv2.COLOR_BGR2GRAY)
+        # Bilateral filter: reduces metallic sheen noise but preserves hole edges
+        gray = cv2.bilateralFilter(gray, d=9, sigmaColor=80, sigmaSpace=80)
+        return gray
+
+    # ── Circle detection ──────────────────────────────────────────────────────
+
+    def _detect_all_circles(self, rgb: np.ndarray) -> np.ndarray:
+        """Run HoughCircles and return Nx3 array [[cx, cy, r], …]."""
+        h, w = rgb.shape[:2]
+        gray = self._preprocess(rgb)
+
+        min_dist = max(15, int(min(h, w) * self.cfg.min_dist_factor))
+
+        raw = cv2.HoughCircles(
+            gray,
+            cv2.HOUGH_GRADIENT,
+            dp=self.cfg.hough_dp,
+            minDist=min_dist,
+            param1=self.cfg.hough_param1,
+            param2=self.cfg.hough_param2,
+            minRadius=self.cfg.bolt_min_radius,
+            maxRadius=self.cfg.bolt_max_radius,
+        )
+        if raw is None:
+            return np.empty((0, 3), dtype=int)
+        return np.round(raw[0]).astype(int)
+
+    def _filter_bolt_holes(self, circles: np.ndarray, image_shape) -> np.ndarray:
+        """
+        Keep only circles that are:
+          • Radius within configured bolt-hole range
+          • Fully inside the image bounds
+          • Area < 2 % of total image area (excludes large bearing journals)
+        """
+        h, w = image_shape[:2]
+        img_area = float(h * w)
+        kept = []
+        for cx, cy, r in circles:
+            area_ratio = (np.pi * r * r) / img_area
+            in_bounds = (r < cx < w - r) and (r < cy < h - r)
+            if area_ratio < 0.02 and in_bounds:
+                kept.append([cx, cy, r])
+        return np.array(kept, dtype=int) if kept else np.empty((0, 3), dtype=int)
+
+    # ── Row clustering ────────────────────────────────────────────────────────
+
+    def _cluster_rows(
+        self, circles: np.ndarray, image_height: int
+    ) -> Tuple[Optional[np.ndarray], Optional[np.ndarray]]:
+        """
+        Split circles into two rows using a Y-midpoint threshold.
+
+        Strategy
+        --------
+        Sort unique Y-values, find the largest gap, split there.
+        This is more stable than K-Means for this structured layout because
+        bolt-hole rows are clearly separated in Y.
+        """
+        if len(circles) < 4:
+            logger.warning("Too few bolt holes (%d) for row clustering.", len(circles))
+            return None, None
+
+        y_vals = circles[:, 1].astype(float)
+
+        # Adaptive split: find largest gap in sorted Y values
+        sorted_y = np.sort(np.unique(y_vals))
+        if len(sorted_y) < 2:
+            return None, None
+
+        gaps = np.diff(sorted_y)
+        min_sep = image_height * self.cfg.row_separation_min
+
+        # Only consider gaps larger than the minimum separation
+        valid_gap_idxs = np.where(gaps >= min_sep)[0]
+        if len(valid_gap_idxs) == 0:
+            logger.warning("Rows too close together; trying mean-split fallback.")
+            split_y = float(np.mean(y_vals))
+        else:
+            best_gap_idx = valid_gap_idxs[np.argmax(gaps[valid_gap_idxs])]
+            split_y = (sorted_y[best_gap_idx] + sorted_y[best_gap_idx + 1]) / 2.0
 
-# # app.py
-# # ─────────────────────────────────────────────────────────────────────────────
-# # Stage 0 : Hough-Circle bolt-hole detection  →  mid-arc brightness check
-# #           Two bolt holes (top + bottom) per bridge are detected, connected
-# #           by a line, and the metallic mid-arc at the midpoint is verified.
-# # Stage 1 : Full-image LAB color metric  →  dark metallic grey → FAIL
-# # Stage 2 : ResNet-50 + CLAHE  →  cosine similarity vs golden template
-# # ─────────────────────────────────────────────────────────────────────────────
+        top_mask = y_vals < split_y
+        bot_mask = ~top_mask
 
-# import gradio as gr
-# import cv2
-# import torch
-# import torch.nn as nn
-# from torchvision import models, transforms
-# from PIL import Image
-# import numpy as np
-# import pickle
-# import os
+        top_circles = circles[top_mask]
+        bot_circles = circles[bot_mask]
 
+        if len(top_circles) == 0 or len(bot_circles) == 0:
+            logger.warning("One row is empty after split.")
+            return None, None
 
-# # ─────────────────────────────────────────────────────────────────────────────
-# # EnginePartDetector
-# # ─────────────────────────────────────────────────────────────────────────────
+        return top_circles, bot_circles
 
-# class EnginePartDetector:
-#     def __init__(
-#         self,
-#         clahe_clip_limit: float = 9.9,
-#         clahe_tile_grid: tuple  = (8, 8),
-#     ):
-#         # ── ResNet-50 backbone (feature extractor only) ───────────────────
-#         self.model = models.resnet50(weights='IMAGENET1K_V1')
-#         self.model = nn.Sequential(*list(self.model.children())[:-1])
-#         self.model.eval()
+    # ── Line fitting ──────────────────────────────────────────────────────────
 
-#         # ── CLAHE applied on LAB L-channel only — no hue/saturation shift ─
-#         self.clahe = cv2.createCLAHE(
-#             clipLimit=clahe_clip_limit,
-#             tileGridSize=clahe_tile_grid,
-#         )
+    @staticmethod
+    def _fit_line(circles: np.ndarray) -> Tuple[float, float]:
+        """
+        Fit y = slope·x + intercept through circle centers.
+        Falls back to a horizontal line through the median Y when < 2 points.
+        """
+        if len(circles) < 2:
+            return 0.0, float(np.median(circles[:, 1]))
 
-#         # ── ResNet ImageNet normalisation ─────────────────────────────────
-#         self.transform = transforms.Compose([
-#             transforms.Resize((224, 224)),
-#             transforms.ToTensor(),
-#             transforms.Normalize(
-#                 mean=[0.485, 0.456, 0.406],
-#                 std=[0.229, 0.224, 0.225],
-#             )
-#         ])
+        x = circles[:, 0].astype(float)
+        y = circles[:, 1].astype(float)
 
-#         self.templates = {}
-#         self.load_templates()
+        # scipy linregress for numerically stable OLS
+        result = stats.linregress(x, y)
+        return float(result.slope), float(result.intercept)
 
-#     # ── CLAHE helper ──────────────────────────────────────────────────────
+    @staticmethod
+    def _line_endpoints(slope: float, intercept: float, width: int):
+        """Return (pt_left, pt_right) spanning the full image width."""
+        return (0, int(intercept)), (width - 1, int(slope * (width - 1) + intercept))
 
-#     def apply_clahe(self, image: np.ndarray) -> np.ndarray:
-#         """CLAHE on LAB L-channel — shadow recovery, no colour shift."""
-#         bgr     = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
-#         lab     = cv2.cvtColor(bgr,   cv2.COLOR_BGR2LAB)
-#         l, a, b = cv2.split(lab)
-#         l_enh   = self.clahe.apply(l)
-#         lab_enh = cv2.merge([l_enh, a, b])
-#         bgr_enh = cv2.cvtColor(lab_enh, cv2.COLOR_LAB2BGR)
-#         return    cv2.cvtColor(bgr_enh,  cv2.COLOR_BGR2RGB)
-
-#     # =========================================================================
-#     # STAGE 0 — Hough-Circle bolt-hole detection + mid-arc check
-#     # =========================================================================
-#     #
-#     #  Top-down engine block view (simplified):
-#     #
-#     #  ┌──────────────────────────────────────────────────────┐
-#     #  │  [saddle1]  │ bridge1 │  [saddle2]  │ bridge2 │ ... │
-#     #  │             ●(top)    │             ●(top)    │     │
-#     #  │             │  ← mid-arc scan box → │         │     │
-#     #  │             ●(bot)    │             ●(bot)    │     │
-#     #  └──────────────────────────────────────────────────────┘
-#     #
-#     #  • Bolt holes = small dark circles (●) detected by HoughCircles
-#     #  • Each bridge has one TOP hole (y ≈ 200) and one BOTTOM hole (y ≈ 490)
-#     #  • The midpoint of the line joining them sits on the metallic mid-arc
-#     #  • A horizontal scan region at the midpoint should be bright (≥ 100)
-#     #  • If it is dark → arc absent → FAIL immediately
-#     #
-#     # =========================================================================
-
-#     def _to_uint8_rgb(self, image) -> np.ndarray:
-#         """Normalise any input to uint8 RGB numpy array."""
-#         if isinstance(image, Image.Image):
-#             return np.array(image.convert("RGB"))
-#         if image.dtype != np.uint8:
-#             return np.clip(image, 0, 255).astype(np.uint8)
-#         return image
+    # ── Saddle crop ───────────────────────────────────────────────────────────
 
-#     def _detect_dark_circles(self, gray: np.ndarray):
-       
-#         h, w = gray.shape
-
-#         # Bilateral filter preserves the hole edge while reducing metallic noise
-#         denoised = cv2.bilateralFilter(gray, 9, 75, 75)
-#         blurred  = cv2.GaussianBlur(denoised, (9, 9), 2)
-
-#         # Scale radii to image width (calibrated on 1280 px reference images)
-#         scale    = w / 1280.0
-#         min_r    = max(6,  int(8  * scale))
-#         max_r    = max(15, int(30 * scale))
-#         min_dist = max(15, int(20 * scale))
-
-#         circles = cv2.HoughCircles(
-#             blurred,
-#             cv2.HOUGH_GRADIENT,
-#             dp        = 1,
-#             minDist   = min_dist,
-#             param1    = 60,   # Canny high threshold
-#             param2    = 28,   # Accumulator threshold (lower = more circles)
-#             minRadius = min_r,
-#             maxRadius = max_r,
-#         )
+    def _crop_between_lines(
+        self,
+        rgb: np.ndarray,
+        top_line: Tuple[float, float],
+        bot_line: Tuple[float, float],
+    ) -> np.ndarray:
+        """
+        Per-column mask: for each x, keep rows from y_top−pad to y_bot+pad.
+        Then bounding-box crop the unmasked region.
+
+        This handles tilted images correctly because the mask boundary follows
+        the actual fitted line slope rather than a fixed row cut.
+        """
+        h, w = rgb.shape[:2]
+        pad = self.cfg.crop_padding_px
+        st, it = top_line
+        sb, ib = bot_line
+
+        mask = np.zeros((h, w), dtype=np.uint8)
+        xs = np.arange(w, dtype=float)
+        y_tops = np.clip((st * xs + it - pad).astype(int), 0, h - 1)
+        y_bots = np.clip((sb * xs + ib + pad).astype(int), 0, h - 1)
+
+        for x in range(w):
+            yt, yb = y_tops[x], y_bots[x]
+            if yb > yt:
+                mask[yt:yb, x] = 255
+
+        # Apply mask (background → black)
+        masked = cv2.bitwise_and(rgb, rgb, mask=mask)
+
+        # Tight bounding box around non-zero pixels
+        ys_nz, xs_nz = np.where(mask > 0)
+        if len(ys_nz) == 0:
+            logger.warning("Empty mask — returning full image.")
+            return rgb
+
+        y0, y1 = ys_nz.min(), ys_nz.max()
+        x0, x1 = xs_nz.min(), xs_nz.max()
+        return masked[y0:y1, x0:x1]
+
+    # ── Public API ────────────────────────────────────────────────────────────
+
+    def extract(
+        self, rgb: np.ndarray
+    ) -> Tuple[np.ndarray, np.ndarray, bool, str]:
+        """
+        Run the full Layer-1 pipeline.
+
+        Returns
+        -------
+        cropped   : np.ndarray  — saddle region (or full image on failure)
+        debug_img : np.ndarray  — annotated image for visual inspection
+        success   : bool
+        message   : str
+        """
+        debug = rgb.copy()
+        h, w = rgb.shape[:2]
+
+        # ── Step 1: detect circles ────────────────────────────────────
+        all_circles = self._detect_all_circles(rgb)
+        bolt_holes  = self._filter_bolt_holes(all_circles, rgb.shape)
+
+        # Draw ALL detected circles in blue (before filtering)
+        for cx, cy, r in all_circles:
+            cv2.circle(debug, (cx, cy), r, (100, 100, 255), 1, cv2.LINE_AA)
+
+        if len(bolt_holes) < 4:
+            msg = (
+                f"⚠️  Only {len(bolt_holes)} bolt holes detected "
+                f"(need ≥ 4). Using full image."
+            )
+            logger.warning(msg)
+            return rgb, debug, False, msg
+
+        # Draw bolt holes in green
+        for cx, cy, r in bolt_holes:
+            cv2.circle(debug, (cx, cy), r, (0, 230, 0), 2, cv2.LINE_AA)
+            cv2.circle(debug, (cx, cy), 4, (0, 230, 0), -1)
+
+        # ── Step 2: cluster into rows ─────────────────────────────────
+        top_circles, bot_circles = self._cluster_rows(bolt_holes, h)
+        if top_circles is None:
+            msg = "⚠️  Row clustering failed. Using full image."
+            logger.warning(msg)
+            return rgb, debug, False, msg
+
+        # Highlight rows: orange=top, red=bottom
+        for cx, cy, r in top_circles:
+            cv2.circle(debug, (cx, cy), r + 5, (255, 165, 0), 2, cv2.LINE_AA)
+            cv2.putText(debug, "T", (cx - 6, cy + 5),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 165, 0), 1, cv2.LINE_AA)
+        for cx, cy, r in bot_circles:
+            cv2.circle(debug, (cx, cy), r + 5, (0, 50, 220), 2, cv2.LINE_AA)
+            cv2.putText(debug, "B", (cx - 6, cy + 5),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 50, 220), 1, cv2.LINE_AA)
+
+        # ── Step 3: fit lines ─────────────────────────────────────────
+        top_line = self._fit_line(top_circles)
+        bot_line  = self._fit_line(bot_circles)
+
+        # Guarantee top_line is visually above bot_line at image center
+        cx_mid = w // 2
+        if (top_line[0] * cx_mid + top_line[1]) > (bot_line[0] * cx_mid + bot_line[1]):
+            top_line, bot_line = bot_line, top_line
+            top_circles, bot_circles = bot_circles, top_circles
+            logger.info("Swapped top/bottom lines to maintain spatial order.")
+
+        # Draw fitted lines
+        pt_t1, pt_t2 = self._line_endpoints(*top_line, w)
+        pt_b1, pt_b2 = self._line_endpoints(*bot_line, w)
+        cv2.line(debug, pt_t1, pt_t2, (255, 165, 0), 2, cv2.LINE_AA)   # orange = top
+        cv2.line(debug, pt_b1, pt_b2, (0,  50, 220), 2, cv2.LINE_AA)   # blue   = bottom
+
+        # Label lines
+        cv2.putText(debug, "TOP LINE",    (10, pt_t1[1] - 8),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 165, 0), 2, cv2.LINE_AA)
+        cv2.putText(debug, "BOTTOM LINE", (10, pt_b1[1] + 18),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0,  50, 220), 2, cv2.LINE_AA)
+
+        # Draw shaded region between lines
+        overlay = debug.copy()
+        for x in range(w):
+            yt = max(0, int(top_line[0] * x + top_line[1]))
+            yb = min(h - 1, int(bot_line[0] * x + bot_line[1]))
+            if yb > yt:
+                overlay[yt:yb, x] = (
+                    overlay[yt:yb, x] * 0.6 + np.array([255, 255, 0]) * 0.4
+                ).astype(np.uint8)
+        cv2.addWeighted(overlay, 0.5, debug, 0.5, 0, debug)
+
+        # ── Step 4: crop saddle ───────────────────────────────────────
+        cropped = self._crop_between_lines(rgb, top_line, bot_line)
+
+        msg = (
+            f"✅  {len(bolt_holes)} bolt holes | "
+            f"top-row: {len(top_circles)} | "
+            f"bot-row: {len(bot_circles)} | "
+            f"Saddle cropped: {cropped.shape[1]}×{cropped.shape[0]} px"
+        )
+        logger.info(msg)
+        return cropped, debug, True, msg
 
-#         if circles is None:
-#             return []
 
-#         circles = np.round(circles[0]).astype(int)
+# ──────────────────────────────────────────────────────────────────────────────
+# LAYER 2 — FeatureExtractor (ResNet-50 + CLAHE)
+# ──────────────────────────────────────────────────────────────────────────────
+class FeatureExtractor:
+    """
+    Deep-feature extraction with luminance-adaptive pre-processing.
 
-#         dark = []
-#         for (x, y, r) in circles:
-#             # Sample pixel brightness at the circle centre
-#             cy = min(y, h - 1)
-#             cx = min(x, w - 1)
-#             y1 = max(0, cy - r // 2);  y2 = min(h, cy + r // 2)
-#             x1 = max(0, cx - r // 2);  x2 = min(w, cx + r // 2)
-#             patch = gray[y1:y2, x1:x2]
-#             if patch.size > 0 and patch.mean() < 80:   # dark = bolt hole
-#                 dark.append((int(x), int(y), int(r)))
+    CLAHE is applied in LAB space on the L-channel only, so colour
+    calibration for the ResNet normalisation is unaffected.
+    """
 
-#         dark.sort(key=lambda c: c[0])   # left → right
-#         return dark
+    def __init__(self, cfg: DetectorConfig):
+        self._clahe = cv2.createCLAHE(
+            clipLimit=cfg.clahe_clip_limit,
+            tileGridSize=cfg.clahe_tile_grid,
+        )
+        # ResNet-50 as fixed backbone; remove average-pool + FC → 2048-D vector
+        backbone = models.resnet50(weights="IMAGENET1K_V1")
+        self.model = nn.Sequential(*list(backbone.children())[:-1])
+        self.model.eval()
 
-#     def _pair_into_bridges(self, circles, img_h: int):
-        
-#         used     = [False] * len(circles)
-#         clusters = []
-
-#         for i, (xi, yi, ri) in enumerate(circles):
-#             if used[i]:
-#                 continue
-#             group  = [(xi, yi, ri)]
-#             used[i] = True
-#             for j, (xj, yj, rj) in enumerate(circles):
-#                 if not used[j] and abs(xi - xj) <= 50:
-#                     group.append((xj, yj, rj))
-#                     used[j] = True
-#             clusters.append(group)
-
-#         pairs   = []
-#         min_sep = 0.18 * img_h
-
-#         for group in clusters:
-#             if len(group) < 2:
-#                 continue
-#             group.sort(key=lambda c: c[1])   # sort by Y
-#             top = group[0]
-#             bot = group[-1]
-#             if (bot[1] - top[1]) >= min_sep:
-#                 pairs.append((top, bot))
-
-#         return pairs   # each entry: ( (tx,ty,tr), (bx,by,br) )
-
-#     def _check_mid_arc(
-#         self,
-#         gray:           np.ndarray,
-#         top_hole:       tuple,
-#         bot_hole:       tuple,
-#         scan_half_w:    int   = 50,
-#         scan_half_h:    int   = 25,
-#         bright_thresh:  int   = 100,
-#         bright_ratio_min: float = 0.50,
-#     ):
-       
-#         tx, ty, _ = top_hole
-#         bx, by, _ = bot_hole
-#         mid_x = int((tx + bx) / 2)
-#         mid_y = int((ty + by) / 2)
+        self._transform = transforms.Compose([
+            transforms.Resize((224, 224)),
+            transforms.ToTensor(),
+            transforms.Normalize(
+                mean=[0.485, 0.456, 0.406],
+                std=[0.229, 0.224, 0.225],
+            ),
+        ])
 
-#         h, w = gray.shape
-#         x1 = max(0, mid_x - scan_half_w);  x2 = min(w, mid_x + scan_half_w)
-#         y1 = max(0, mid_y - scan_half_h);  y2 = min(h, mid_y + scan_half_h)
+    # ── Internal CLAHE ────────────────────────────────────────────────────────
 
-#         region = gray[y1:y2, x1:x2]
-#         if region.size == 0:
-#             return False, dict(mean=0, bright_ratio=0, dark_ratio=0,
-#                                mid=(mid_x, mid_y), roi=(x1, y1, x2, y2))
+    def _apply_clahe(self, rgb: np.ndarray) -> np.ndarray:
+        bgr = cv2.cvtColor(rgb, cv2.COLOR_RGB2BGR)
+        lab = cv2.cvtColor(bgr, cv2.COLOR_BGR2LAB)
+        l, a, b = cv2.split(lab)
+        l_enh = self._clahe.apply(l)
+        bgr_enh = cv2.cvtColor(cv2.merge([l_enh, a, b]), cv2.COLOR_LAB2BGR)
+        return cv2.cvtColor(bgr_enh, cv2.COLOR_BGR2RGB)
 
-#         mean_b       = float(region.mean())
-#         bright_ratio = float((region >= bright_thresh).sum()) / region.size
-#         dark_ratio   = float((region < 50).sum()) / region.size
+    # ── Public API ────────────────────────────────────────────────────────────
 
-#         is_present = (mean_b >= bright_thresh) and (bright_ratio >= bright_ratio_min)
+    def __call__(self, image) -> np.ndarray:
+        """Accept PIL Image or np.ndarray, return 2048-D feature vector."""
+        if isinstance(image, Image.Image):
+            arr = np.array(image.convert("RGB"))
+        elif isinstance(image, np.ndarray):
+            arr = image.astype(np.uint8)
+        else:
+            raise TypeError(f"Unsupported image type: {type(image)}")
 
-#         return is_present, dict(
-#             mean=mean_b, bright_ratio=bright_ratio, dark_ratio=dark_ratio,
-#             mid=(mid_x, mid_y), roi=(x1, y1, x2, y2),
-#         )
+        arr = self._apply_clahe(arr)
+        # Light Gaussian blur suppresses metallic sheen amplified by CLAHE
+        arr = cv2.GaussianBlur(arr, (3, 3), 0)
 
-#     def stage0_mid_arc(self, image: np.ndarray):
-        
-#         image = self._to_uint8_rgb(image)
-#         h, w  = image.shape[:2]
-#         gray  = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
-
-#         # Enhance contrast before circle detection
-#         cg       = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
-#         gray_enh = cg.apply(gray)
-
-#         # ── Step 1: detect dark bolt holes ────────────────────────────────
-#         circles = self._detect_dark_circles(gray_enh)
-#         debug   = image.copy()
-
-#         if len(circles) < 2:
-#             reason = (f"Only {len(circles)} bolt hole(s) found "
-#                       f"(need ≥ 2). Stage 0 skipped.")
-#             return "SKIP", reason, debug, []
-
-#         # Draw yellow circles for all detected bolt holes
-#         for (x, y, r) in circles:
-#             cv2.circle(debug, (x, y), r + 4, (255, 220, 0), 2)
-#             cv2.circle(debug, (x, y), 3,     (255, 220, 0), -1)
-
-#         # ── Step 2: pair holes into bridges ───────────────────────────────
-#         pairs = self._pair_into_bridges(circles, h)
-
-#         if not pairs:
-#             reason = (f"{len(circles)} holes detected but no bridge pairs formed. "
-#                       f"Stage 0 skipped.")
-#             return "SKIP", reason, debug, []
-
-#         # ── Step 3: check mid-arc for each bridge ─────────────────────────
-#         bridge_results = []
-#         absent         = []
-
-#         for i, (top, bot) in enumerate(pairs, 1):
-#             present, stats = self._check_mid_arc(gray_enh, top, bot)
-
-#             bridge_results.append(dict(
-#                 bridge=i, top=top, bot=bot,
-#                 present=present, stats=stats,
-#             ))
-
-#             mx, my       = stats['mid']
-#             x1,y1,x2,y2 = stats['roi']
-#             col          = (0, 230, 0) if present else (0, 0, 255)
-
-#             # Bridge axis line (cyan)
-#             cv2.line(debug, (top[0], top[1]), (bot[0], bot[1]), (0, 200, 255), 2)
-#             # Scan-box (green = OK, red = missing arc)
-#             cv2.rectangle(debug, (x1, y1), (x2, y2), col, 2)
-#             # Mid-point dot
-#             cv2.circle(debug, (mx, my), 5, col, -1)
-#             # Label
-#             label = f"B{i} {'OK' if present else 'MISS'}  {stats['mean']:.0f}"
-#             cv2.putText(debug, label, (mx - 30, my - 32),
-#                         cv2.FONT_HERSHEY_SIMPLEX, 0.55, col, 2)
-
-#             if not present:
-#                 absent.append(
-#                     f"Bridge {i} "
-#                     f"(brightness={stats['mean']:.0f}, "
-#                     f"bright_ratio={stats['bright_ratio']:.0%})"
-#                 )
-
-#         # ── Step 4: decision ──────────────────────────────────────────────
-#         if absent:
-#             status = "FAIL"
-#             reason = f"Mid-arc ABSENT on: {', '.join(absent)}"
-#         else:
-#             n = len(pairs)
-#             status = "PASS"
-#             reason = f"Mid-arc PRESENT on all {n} bridge(s) checked."
+        tensor = self._transform(Image.fromarray(arr)).unsqueeze(0)
+        with torch.no_grad():
+            feat = self.model(tensor).squeeze().numpy()
+        return feat  # shape (2048,)
 
-#         return status, reason, debug, bridge_results
 
-#     # =========================================================================
-#     # STAGE 1 — Full-image LAB color metric
-#     # =========================================================================
+# ──────────────────────────────────────────────────────────────────────────────
+# LAYER 3 — TemplateMatcher
+# ──────────────────────────────────────────────────────────────────────────────
+class TemplateMatcher:
+    """
+    Manages the golden-template library and performs cosine-similarity matching.
 
-#     def stage1_color(self, image: np.ndarray):
-       
-#         image    = self._to_uint8_rgb(image)
-#         image_eh = self.apply_clahe(image)
+    Templates are stored as {part_name: feature_vector} and persisted to disk
+    via pickle so they survive Gradio restarts.
+    """
 
-#         bgr = cv2.cvtColor(image_eh, cv2.COLOR_RGB2BGR)
-#         lab = cv2.cvtColor(bgr, cv2.COLOR_BGR2LAB)
-#         l, a, b = cv2.split(lab)
-
-#         # Mask: keep only bright metallic areas (saddles > engine body)
-#         _, mask = cv2.threshold(l, 80, 255, cv2.THRESH_BINARY)
-#         k       = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (15, 15))
-#         mask    = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, k)
-#         mask    = cv2.morphologyEx(mask, cv2.MORPH_OPEN,  k)
-#         if np.sum(mask) < 0.05 * mask.size:   # fallback: use whole image
-#             mask = np.ones_like(l) * 255
-
-#         total    = np.sum(mask > 0)
-#         l_mean   = cv2.mean(l, mask=mask)[0]
-#         a_mean   = cv2.mean(a, mask=mask)[0]
-#         b_mean   = cv2.mean(b, mask=mask)[0]
-#         sat      = np.sqrt((a_mean - 128) ** 2 + (b_mean - 128) ** 2)
-#         dratio   = np.sum((l < 105) & (mask > 0)) / total if total else 0
-#         hist     = cv2.calcHist([l], [0], mask, [256], [0, 256]).flatten()
-#         hist    /= hist.sum()
-#         dmass    = float(hist[:105].sum())
-
-#         fails = []
-#         if l_mean < 105:           fails.append(f"L-mean={l_mean:.1f} (<105)")
-#         if dratio  > 0.15:         fails.append(f"dark-pixel ratio={dratio:.1%} (>15%)")
-#         if dmass   > 0.20:         fails.append(f"dark histogram mass={dmass:.1%} (>20%)")
-
-#         if fails:
-#             return "FAIL", "Dark metallic grey: " + ";  ".join(fails)
-
-#         return "PASS", (
-#             f"Light grey surface  L={l_mean:.1f}  "
-#             f"dark_ratio={dratio:.1%}  sat={sat:.1f}"
-#         )
+    def __init__(self, cfg: DetectorConfig, extractor: FeatureExtractor):
+        self.cfg       = cfg
+        self.extractor = extractor
+        self.templates: dict[str, np.ndarray] = {}
+        self._load()
 
-#     # =========================================================================
-#     # STAGE 2 — ResNet-50 + CLAHE feature extraction & template matching
-#     # =========================================================================
+    # ── Persistence ───────────────────────────────────────────────────────────
 
-#     def extract_features(self, image) -> np.ndarray:
-#         if isinstance(image, Image.Image):
-#             image = np.array(image.convert("RGB"))
-#         if isinstance(image, np.ndarray):
-#             if image.dtype != np.uint8:
-#                 image = np.clip(image, 0, 255).astype(np.uint8)
-#             if image.ndim == 2:
-#                 image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)
+    def _load(self):
+        if os.path.exists(self.cfg.templates_path):
+            try:
+                with open(self.cfg.templates_path, "rb") as f:
+                    self.templates = pickle.load(f)
+                logger.info("Loaded %d templates from %s.",
+                            len(self.templates), self.cfg.templates_path)
+            except Exception as exc:
+                logger.error("Failed to load templates: %s", exc)
+                self.templates = {}
 
-#         image = self.apply_clahe(image)
-#         image = cv2.GaussianBlur(image, (3, 3), 0)
+    def _save(self):
+        with open(self.cfg.templates_path, "wb") as f:
+            pickle.dump(self.templates, f)
 
-#         tensor = self.transform(Image.fromarray(image)).unsqueeze(0)
-#         with torch.no_grad():
-#             features = self.model(tensor).squeeze().numpy()
-#         return features
+    # ── Template management ───────────────────────────────────────────────────
 
-#     def cosine_similarity(self, f1, f2):
-#         return float(
-#             np.dot(f1, f2) / (np.linalg.norm(f1) * np.linalg.norm(f2) + 1e-8)
-#         )
+    def add_template(self, image, part_name: str) -> str:
+        if image is None or not part_name.strip():
+            return "❌  Provide both an image and a part name."
+        feat = self.extractor(image)
+        self.templates[part_name.strip()] = feat
+        self._save()
+        return f"✅  Template '{part_name.strip()}' saved ({len(self.templates)} total)."
 
-#     # ── Template management ───────────────────────────────────────────────
+    def list_templates(self) -> str:
+        if not self.templates:
+            return "No templates saved yet."
+        return "\n".join(f"  • {n}" for n in sorted(self.templates))
 
-#     def save_template(self, image, part_name: str) -> str:
-#         if image is None or not part_name:
-#             return "Please provide both image and part name"
-#         self.templates[part_name] = self.extract_features(image)
-#         with open('templates.pkl', 'wb') as f:
-#             pickle.dump(self.templates, f)
-#         return f"✅ Template '{part_name}' saved successfully!"
+    # ── Matching ──────────────────────────────────────────────────────────────
 
-#     def load_templates(self):
-#         if os.path.exists('templates.pkl'):
-#             try:
-#                 with open('templates.pkl', 'rb') as f:
-#                     self.templates = pickle.load(f)
-#             except Exception:
-#                 self.templates = {}
+    @staticmethod
+    def _cosine(a: np.ndarray, b: np.ndarray) -> float:
+        return float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b) + 1e-12))
 
-#     # ── 3-stage detection pipeline ────────────────────────────────────────
+    def match(
+        self,
+        image,
+        threshold: Optional[float] = None,
+    ) -> Tuple[str, Optional[str]]:
+        """
+        Match *image* against all stored templates.
+
+        Returns
+        -------
+        report : str   — human-readable results
+        label  : str | None — best match name if above threshold, else None
+        """
+        if image is None:
+            return "❌  No image provided.", None
+        if not self.templates:
+            return "⚠️  No templates stored. Add templates first.", None
 
-#     def match_part(self, image, threshold: float = 0.7):
-        
-#         if image is None:
-#             return "Please provide an image", None
-#         if not self.templates:
-#             return "⚠️ No templates available. Add templates first.", None
-
-#         lines = []
-
-#         # ── Stage 0: mid-arc ──────────────────────────────────────────────
-#         s0, r0, _, br0 = self.stage0_mid_arc(image)
-
-#         if s0 == "FAIL":
-#             lines += [
-#                 "# 🔴 DEFECTED PIECE\n",
-#                 "**Stage 0 — Mid-Arc Check** ❌  FAILED",
-#                 f"> {r0}", "",
-#                 "**Bridge details:**",
-#             ]
-#             for br in br0:
-#                 s   = br['stats']
-#                 ico = "✓" if br['present'] else "✗"
-#                 lines.append(
-#                     f"  {ico} Bridge {br['bridge']}:  "
-#                     f"brightness={s['mean']:.0f}   "
-#                     f"bright_ratio={s['bright_ratio']:.0%}"
-#                 )
-#             lines.append("\n_Stage 1 & 2 skipped._")
-#             return "\n".join(lines), None
-
-#         # Log Stage-0 result (PASS or SKIP)
-#         if s0 == "SKIP":
-#             lines.append(f"**Stage 0 — Mid-Arc Check** ⚠️  SKIPPED  _{r0}_")
-#         else:
-#             lines.append("**Stage 0 — Mid-Arc Check** ✅  PASSED")
-#             lines.append(f"> {r0}")
-#             for br in br0:
-#                 s = br['stats']
-#                 lines.append(
-#                     f"  ✓ Bridge {br['bridge']}:  "
-#                     f"brightness={s['mean']:.0f}   "
-#                     f"bright_ratio={s['bright_ratio']:.0%}"
-#                 )
-#         lines.append("")
-
-#         # ── Stage 1: color metric ─────────────────────────────────────────
-#         s1, r1 = self.stage1_color(image)
-
-#         if s1 == "FAIL":
-#             lines += [
-#                 "# 🔴 DEFECTED PIECE\n",
-#                 "**Stage 1 — Color-Metric Check** ❌  FAILED",
-#                 f"> {r1}",
-#                 "\n_Stage 2 skipped._",
-#             ]
-#             return "\n".join(lines), None
-
-#         lines.append("**Stage 1 — Color-Metric Check** ✅  PASSED")
-#         lines.append(f"> {r1}")
-#         lines.append("")
-
-#         # ── Stage 2: ResNet template match ────────────────────────────────
-#         qf   = self.extract_features(image)
-#         sims = sorted(
-#             [(n, self.cosine_similarity(qf, f)) for n, f in self.templates.items()],
-#             key=lambda x: x[1], reverse=True,
-#         )
-#         best_name, best_score = sims[0]
-
-#         lines.append("**Stage 2 — Template Matching**")
-#         lines.append(f"  Best match: `{best_name}` → **{best_score:.2%}**")
-#         lines.append(f"  Threshold:  {threshold:.0%}")
-#         lines.append("")
-#         lines.append("**All Similarities:**")
-#         for name, score in sims:
-#             bar = "█" * int(score * 20) + "░" * (20 - int(score * 20))
-#             lines.append(f"  `{name}` {bar} {score:.2%}")
-
-#         if best_score >= threshold:
-#             lines.insert(0, "# ✅ PERFECT PIECE\n")
-#             lines.append(f"\n✅ **Final Decision**: MATCHED — `{best_name}`")
-#             return "\n".join(lines), best_name
-#         else:
-#             lines.insert(0, "# 🟡 DEFECTED PIECE\n")
-#             lines.append(
-#                 f"\n❌ **Final Decision**: NO MATCH  "
-#                 f"(best {best_score:.2%} < threshold {threshold:.0%})"
-#             )
-#             return "\n".join(lines), None
+        thr = threshold if threshold is not None else self.cfg.default_threshold
+        feat = self.extractor(image)
 
+        scores = sorted(
+            ((name, self._cosine(feat, vec)) for name, vec in self.templates.items()),
+            key=lambda x: x[1],
+            reverse=True,
+        )
 
-# # ─────────────────────────────────────────────────────────────────────────────
-# # Live-camera edge preview  (streaming, lightweight)
-# # ─────────────────────────────────────────────────────────────────────────────
+        best_name, best_score = scores[0]
+        matched = best_score >= thr
+
+        lines = [
+            f"🔍 **Best Match** : {best_name}",
+            f"📊 **Confidence** : {best_score:.2%}",
+            f"{'✅ MATCHED' if matched else '❌ NO MATCH'} (threshold {thr:.0%})",
+            "",
+            "**All Scores:**",
+        ]
+        for name, score in scores:
+            bar = "█" * int(score * 20)
+            lines.append(f"  {name:<30} {score:.2%}  {bar}")
+
+        return "\n".join(lines), (best_name if matched else None)
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# LAYER 4 — MultiLayerPipeline (orchestrator)
+# ──────────────────────────────────────────────────────────────────────────────
+class MultiLayerPipeline:
+    """
+    Ties Layers 1–3 together and drives the Gradio UI callbacks.
+    """
+
+    def __init__(self, cfg: DetectorConfig):
+        self.cfg       = cfg
+        self.extractor = FeatureExtractor(cfg)
+        self.saddle    = SaddleRegionExtractor(cfg)
+    
+        # Matcher is initialised *after* extractor so it can use it
+        self.matcher   = TemplateMatcher(cfg, self.extractor)
 
-# def live_edge_preview(frame: np.ndarray) -> np.ndarray:
-#     if frame is None:
-#         return frame
-#     if frame.dtype != np.uint8:
-#         frame = np.clip(frame, 0, 255).astype(np.uint8)
-#     gray    = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY)
-#     blurred = cv2.GaussianBlur(gray, (5, 5), 0)
-#     clahe   = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
-#     enh     = clahe.apply(blurred)
-#     edges   = cv2.Canny(enh, 30, 120)
-#     dim     = (frame * 0.35).astype(np.uint8)
-#     dim[edges > 0] = [0, 220, 220]
-#     return dim
+    # ── Detection pipeline ────────────────────────────────────────────────────
 
+    def detect(
+        self,
+        raw_image: np.ndarray,
+        threshold: float,
+    ) -> Tuple[str, Optional[str], np.ndarray, np.ndarray]:
+        """
+        Full detection pipeline.
+
+        1. Layer-1  → crop saddle region
+        2. Layer-2  → extract features from cropped saddle
+        3. Layer-3  → match against templates
+
+        Returns
+        -------
+        report        : str
+        label         : str | None
+        debug_image   : np.ndarray  (annotated with circles + lines)
+        cropped_image : np.ndarray  (the extracted saddle region sent to matching)
+        """
+        if raw_image is None:
+            return "❌  No image provided.", None, np.zeros((100, 100, 3), np.uint8), np.zeros((100, 100, 3), np.uint8)
+
+        # Layer 1 — geometric extraction
+        cropped, debug_img, geo_ok, geo_msg = self.saddle.extract(raw_image)
+
+        extraction_status = (
+            f"**Layer-1 (Geometric):** {geo_msg}\n\n"
+        )
 
-# # ─────────────────────────────────────────────────────────────────────────────
-# # Gradio callbacks
-# # ─────────────────────────────────────────────────────────────────────────────
+        # Layer 2+3 — feature extraction + matching on the cropped saddle
+        match_report, label = self.matcher.match(cropped, threshold)
 
-# detector = EnginePartDetector()
+        full_report = extraction_status + match_report
 
+        return full_report, label, debug_img, cropped
 
-# def detect_part(image, threshold):
-#     return detector.match_part(image, threshold)
+    # ── Template management pass-throughs ─────────────────────────────────────
 
+    def add_template(self, image: np.ndarray, part_name: str) -> str:
+        """Save template using the raw upload (no saddle crop — full control image)."""
+        return self.matcher.add_template(image, part_name)
 
-# def debug_arc(image):
-#     """Return annotated debug image + per-bridge text report for Stage 0."""
-#     if image is None:
-#         return None, "Please upload an image."
-#     if isinstance(image, np.ndarray) and image.dtype != np.uint8:
-#         image = np.clip(image, 0, 255).astype(np.uint8)
-
-#     status, reason, debug_img, bridges = detector.stage0_mid_arc(image)
-
-#     lines = [
-#         f"**Stage 0 Status**: `{status}`",
-#         f"**Reason**: {reason}",
-#         "",
-#         "**Legend:**  🟡 yellow = bolt hole   |  blue line = bridge axis",
-#         "🟢 green box = arc PRESENT   |  🔴 red box = arc ABSENT",
-#         "",
-#         "**Bridge Results:**",
-#     ]
-#     for br in bridges:
-#         s   = br['stats']
-#         ico = "✓ PRESENT" if br['present'] else "✗ ABSENT"
-#         lines.append(
-#             f"  Bridge {br['bridge']}: {ico}  |  "
-#             f"brightness={s['mean']:.0f}  |  "
-#             f"bright_ratio={s['bright_ratio']:.0%}  |  "
-#             f"dark_ratio={s['dark_ratio']:.0%}"
-#         )
+    def add_template_with_crop(self, image: np.ndarray, part_name: str) -> Tuple[str, np.ndarray, np.ndarray]:
+        """
+        Optional: crop saddle from the template image too, then save.
+        Returns status + debug + cropped for visual confirmation.
+        """
+        if image is None or not part_name.strip():
+            blank = np.zeros((100, 100, 3), np.uint8)
+            return "❌  Provide both image and name.", blank, blank
 
-#     return debug_img, "\n".join(lines)
+        cropped, debug_img, ok, geo_msg = self.saddle.extract(image)
+        status = self.matcher.add_template(cropped, part_name)
+        return f"{geo_msg}\n{status}", debug_img, cropped
 
+    def list_templates(self) -> str:
+        return self.matcher.list_templates()
 
-# def add_template(image, part_name):
-#     return detector.save_template(image, part_name)
 
+# ──────────────────────────────────────────────────────────────────────────────
+# Initialise pipeline (single global instance — Gradio is single-process)
+# ──────────────────────────────────────────────────────────────────────────────
+cfg      = DetectorConfig()
+pipeline = MultiLayerPipeline(cfg)
 
-# def list_templates():
-#     if not detector.templates:
-#         return "No templates saved yet"
-#     return "\n".join(f"- {n}" for n in detector.templates)
-
-
-# def cb_capture(frame):
-#     return frame
-
-
-# # ─────────────────────────────────────────────────────────────────────────────
-# # CSS — industrial dark theme (kept from reference)
-# # ─────────────────────────────────────────────────────────────────────────────
-
-# CSS = """
-# @import url('https://fonts.googleapis.com/css2?family=Share+Tech+Mono&family=Barlow:wght@300;400;600;700&display=swap');
-# :root {
-#     --bg:      #0d0f12; --surface: #151820; --card: #1c2030;
-#     --border:  #2a3045; --accent:  #00e5ff; --accent2: #ff6b35;
-#     --text:    #d0d8e8; --muted:   #5a6480;
-#     --mono:    'Share Tech Mono', monospace;
-#     --sans:    'Barlow', sans-serif;
-# }
-# body, .gradio-container { background: var(--bg) !important; font-family: var(--sans) !important; color: var(--text) !important; }
-# .tabs > .tab-nav { background: var(--surface) !important; border-bottom: 2px solid var(--border) !important; }
-# .tabs > .tab-nav button { font-family: var(--mono) !important; font-size: 0.75rem !important; letter-spacing: 0.1em !important; text-transform: uppercase !important; color: var(--muted) !important; background: transparent !important; border: none !important; padding: 10px 18px !important; }
-# .tabs > .tab-nav button.selected, .tabs > .tab-nav button:hover { color: var(--accent) !important; border-bottom: 2px solid var(--accent) !important; }
-# button.primary { background: var(--accent) !important; color: #000 !important; font-family: var(--mono) !important; font-weight: 700 !important; letter-spacing: 0.08em !important; text-transform: uppercase !important; border: none !important; border-radius: 4px !important; }
-# button.secondary { background: transparent !important; color: var(--accent2) !important; border: 1px solid var(--accent2) !important; font-family: var(--mono) !important; border-radius: 4px !important; }
-# .gr-markdown { font-family: var(--mono) !important; font-size: 0.8rem !important; color: var(--text) !important; background: var(--surface) !important; border: 1px solid var(--border) !important; border-radius: 4px !important; padding: 14px !important; line-height: 1.75 !important; }
-# input[type="range"] { accent-color: var(--accent) !important; }
-# .live-tag { font-family: var(--mono); font-size: 0.68rem; color: var(--accent); letter-spacing: 0.15em; text-transform: uppercase; margin-bottom: 4px; }
-# """
-
-# # ─────────────────────────────────────────────────────────────────────────────
-# # Gradio UI
-# # ─────────────────────────────────────────────────────────────────────────────
-
-# with gr.Blocks(title="ENGINE PART DETECTION") as demo:
-
-#     gr.HTML("""
-#     <div style="padding:18px 0 6px;border-bottom:1px solid #2a3045;margin-bottom:18px;">
-#       <span style="font-family:'Share Tech Mono',monospace;font-size:1.5rem;color:#00e5ff;letter-spacing:0.1em;">
-#         ⚙ ENGINE SADDLE DETECTION SYSTEM
-#       </span><br>
-#       <span style="font-family:'Share Tech Mono',monospace;font-size:0.72rem;color:#5a6480;letter-spacing:0.06em;">
-#         STAGE 0: HOUGH MID-ARC  ·  STAGE 1: LAB COLOR METRIC  ·  STAGE 2: RESNET TEMPLATE MATCH
-#       </span>
-#     </div>
-#     """)
 
-#     with gr.Tabs():
-
-#         # ── Tab 1: Detect ─────────────────────────────────────────────────
-#         with gr.TabItem("DETECT"):
-#             gr.HTML("<p class='live-tag' style='margin-bottom:8px;'>Upload or capture · 3-stage detection pipeline</p>")
-#             with gr.Row():
-#                 with gr.Column(scale=1):
-#                     detect_input = gr.Image(
-#                         sources=["upload", "webcam"],
-#                         type="numpy", label="Part Image", height=320,
-#                     )
-#                     threshold_slider = gr.Slider(
-#                         0.50, 0.95, value=0.70, step=0.01,
-#                         label="Similarity Threshold  (Stage 2)",
-#                     )
-#                     detect_btn = gr.Button("▶  RUN 3-STAGE DETECTION", variant="primary")
-
-#                 with gr.Column(scale=1):
-#                     detect_output = gr.Markdown(label="Detection Report")
-#                     match_label   = gr.Label(label="Matched Part", num_top_classes=3)
-
-#             detect_btn.click(
-#                 fn=detect_part,
-#                 inputs=[detect_input, threshold_slider],
-#                 outputs=[detect_output, match_label],
-#                 api_name="detect_part",
-#             )
+# ──────────────────────────────────────────────────────────────────────────────
+# Gradio UI
+# ──────────────────────────────────────────────────────────────────────────────
+CSS = """
+#title { text-align: center; }
+.status-box { font-family: monospace; font-size: 0.85rem; }
+"""
 
-#         # ── Tab 2: Debug Arc ──────────────────────────────────────────────
-#         with gr.TabItem("🔬 DEBUG ARC"):
-#             gr.HTML("""
-#             <p class='live-tag'>Visualise bolt-hole detection and mid-arc scan regions</p>
-#             <p style='font-family:Share Tech Mono,monospace;font-size:0.72rem;color:#5a6480;'>
-#               🟡 Yellow circles = bolt holes &nbsp;|&nbsp;
-#               Blue line = bridge axis &nbsp;|&nbsp;
-#               🟢 Green box = arc PRESENT &nbsp;|&nbsp;
-#               🔴 Red box = arc ABSENT
-#             </p>
-#             """)
-#             with gr.Row():
-#                 with gr.Column(scale=1):
-#                     debug_input = gr.Image(
-#                         sources=["upload", "webcam"],
-#                         type="numpy", label="Input Image", height=320,
-#                     )
-#                     debug_btn = gr.Button("🔬  RUN ARC DEBUG", variant="primary")
-
-#                 with gr.Column(scale=1):
-#                     debug_out_img = gr.Image(label="Annotated Debug View", height=320)
-#                     debug_out_txt = gr.Markdown(label="Bridge Results")
-
-#             debug_btn.click(
-#                 fn=debug_arc,
-#                 inputs=[debug_input],
-#                 outputs=[debug_out_img, debug_out_txt],
-#             )
+with gr.Blocks(title="Engine Part Detection — Multi-Layer CV System", css=CSS) as demo:
 
-#         # ── Tab 3: Live Camera ────────────────────────────────────────────
-#         with gr.TabItem("📷 LIVE CAMERA"):
-#             gr.HTML("<p class='live-tag'>● Live feed  ·  Capture frame  ·  Run 3-stage detection</p>")
-#             with gr.Row():
-#                 with gr.Column(scale=1):
-#                     gr.HTML("<div class='live-tag'>● LIVE FEED</div>")
-#                     live_input  = gr.Image(sources=["webcam"], streaming=True,
-#                                            type="numpy", height=280)
-#                     gr.HTML("<div class='live-tag' style='margin-top:8px;'>CLAHE EDGE OVERLAY</div>")
-#                     live_output = gr.Image(label="Edge Preview", height=280)
-
-#                 with gr.Column(scale=1):
-#                     gr.HTML("<div class='live-tag'>CAPTURED FRAME</div>")
-#                     captured_frame = gr.Image(type="numpy", height=280, interactive=False)
-#                     with gr.Row():
-#                         capture_btn     = gr.Button("📸 CAPTURE FRAME", variant="primary")
-#                         detect_live_btn = gr.Button("▶ DETECT CAPTURED", variant="secondary")
-#                     live_threshold = gr.Slider(0.50, 0.95, value=0.70, step=0.01,
-#                                                label="Similarity Threshold")
-#                     live_result = gr.Markdown(label="Detection Result")
-#                     live_label  = gr.Label(label="Matched Part", num_top_classes=3)
-
-#             live_input.stream(fn=live_edge_preview,
-#                               inputs=[live_input], outputs=[live_output])
-#             capture_btn.click(fn=cb_capture,
-#                               inputs=[live_input], outputs=[captured_frame])
-#             detect_live_btn.click(
-#                 fn=detect_part,
-#                 inputs=[captured_frame, live_threshold],
-#                 outputs=[live_result, live_label],
-#             )
+    gr.Markdown(
+        """
+        # 🔧 Engine Part Detection System
+        ### Multi-Layer Computer Vision Architecture
+        | Layer | Role |
+        |-------|------|
+        | **L1 — Geometric** | HoughCircles → bolt-hole centers → line fitting → saddle crop |
+        | **L2 — Feature**   | CLAHE + GaussianBlur → ResNet-50 (2048-D embeddings) |
+        | **L3 — Matching**  | Cosine-similarity against golden templates |
+        """,
+        elem_id="title",
+    )
 
-#         # ── Tab 4: Add Template ───────────────────────────────────────────
-#         with gr.TabItem("➕ ADD TEMPLATE"):
-#             gr.HTML("<p class='live-tag'>Register reference images · CLAHE + ResNet-50 feature pipeline</p>")
-#             with gr.Row():
-#                 with gr.Column(scale=1):
-#                     template_input  = gr.Image(sources=["upload", "webcam"],
-#                                                type="numpy", label="Reference Image", height=300)
-#                     part_name_input = gr.Textbox(
-#                         label="Part Name",
-#                         placeholder="e.g.  bearing_saddle_ok  /  piston_perfect",
-#                     )
-#                     add_btn = gr.Button("💾  SAVE TEMPLATE", variant="primary")
-
-#                 with gr.Column(scale=1):
-#                     add_output = gr.Markdown(label="Status")
-#                     gr.HTML("""
-#                     <div style="background:#1c2030;border:1px solid #2a3045;border-radius:4px;
-#                                 padding:14px;font-family:'Share Tech Mono',monospace;
-#                                 font-size:0.72rem;color:#5a6480;line-height:1.9;">
-#                         Feature extraction pipeline:<br>
-#                         &nbsp; 1 · CLAHE on LAB L-channel  (shadow recovery)<br>
-#                         &nbsp; 2 · Gaussian blur 3×3  (metallic sheen suppression)<br>
-#                         &nbsp; 3 · ResNet-50 backbone  →  2048-D feature vector<br>
-#                         &nbsp; 4 · Persisted to  templates.pkl
-#                     </div>
-#                     """)
-
-#             add_btn.click(
-#                 fn=add_template,
-#                 inputs=[template_input, part_name_input],
-#                 outputs=[add_output],
-#                 api_name="add_template",
-#             )
+    # ── Tab 1: Detect ──────────────────────────────────────────────────────────
+    with gr.Tab("🔍 Detect Part"):
+        gr.Markdown("Upload or capture an engine image. Layer-1 will automatically locate the bearing-saddle region before matching.")
 
-#         # ── Tab 5: Manage Templates ───────────────────────────────────────
-#         with gr.TabItem("📋 TEMPLATES"):
-#             gr.HTML("<p class='live-tag'>View and remove saved templates</p>")
-#             with gr.Row():
-#                 with gr.Column(scale=2):
-#                     template_list_out = gr.Markdown(label="Saved Templates")
-#                     refresh_btn = gr.Button("↻  REFRESH LIST", variant="secondary")
-
-#                 with gr.Column(scale=1):
-#                     delete_name   = gr.Textbox(label="Part name to delete", placeholder="exact name…")
-#                     delete_btn    = gr.Button("🗑  DELETE TEMPLATE", variant="secondary")
-#                     delete_status = gr.Markdown(label="Status")
-
-#             def cb_delete(name):
-#                 if name in detector.templates:
-#                     del detector.templates[name]
-#                     with open('templates.pkl', 'wb') as f:
-#                         pickle.dump(detector.templates, f)
-#                     msg = f"🗑️ Template '{name}' deleted."
-#                 else:
-#                     msg = f"⚠️ '{name}' not found."
-#                 return msg, list_templates()
-
-#             refresh_btn.click(fn=list_templates, outputs=[template_list_out],
-#                               api_name="list_templates")
-#             delete_btn.click(fn=cb_delete, inputs=[delete_name],
-#                              outputs=[delete_status, template_list_out])
-
-#             # Hidden machine-readable endpoint (matches reference client)
-#             raw_list_btn = gr.Button("RAW LIST", visible=False)
-#             raw_list_btn.click(
-#                 fn=lambda: ",".join(sorted(detector.templates.keys())),
-#                 outputs=[],
-#                 api_name="list_templates_raw",
-#             )
+        with gr.Row():
+            with gr.Column(scale=1):
+                detect_input     = gr.Image(sources=["upload", "webcam"], type="numpy", label="Input Image")
+                threshold_slider = gr.Slider(0.50, 0.95, value=cfg.default_threshold,
+                                             step=0.01, label="Similarity Threshold")
+                detect_btn       = gr.Button("🚀 Detect Part", variant="primary")
 
-#             demo.load(fn=list_templates, outputs=[template_list_out])
+            with gr.Column(scale=1):
+                detect_report = gr.Textbox(label="Detection Report",
+                                           lines=14, elem_classes=["status-box"])
+                match_label   = gr.Label(label="Matched Part")
 
+        with gr.Row():
+            debug_output   = gr.Image(label="Layer-1 Debug View  (bolt holes + fitted lines)")
+            cropped_output = gr.Image(label="Cropped Saddle  (sent to matching)")
 
-# # ───────────────────────────────────────────────────────────��─────────────────
+        detect_btn.click(
+            fn=pipeline.detect,
+            inputs=[detect_input, threshold_slider],
+            outputs=[detect_report, match_label, debug_output, cropped_output],
+            api_name="detect",
+        )
 
-# if __name__ == "__main__":
-#     demo.launch(
-#         css=CSS,
-#         server_name="0.0.0.0",
-#         server_port=7860,
-#         ssr_mode=False,
-#     )
+    # ── Tab 2: Add Template ────────────────────────────────────────────────────
+    with gr.Tab("➕ Add Template"):
+        gr.Markdown(
+            "Two modes:\n"
+            "- **Raw upload**: save the full image as-is (best for controlled reference shots)\n"
+            "- **Auto-crop + save**: Layer-1 extracts the saddle first, then saves that as the template"
+        )
+
+        with gr.Row():
+            with gr.Column():
+                tpl_input     = gr.Image(sources=["upload"], type="numpy", label="Reference Image")
+                tpl_name      = gr.Textbox(label="Part Name  (e.g. bearing_saddle_good)", placeholder="part_name")
+
+                with gr.Row():
+                    save_raw_btn    = gr.Button("💾 Save Raw",              variant="secondary")
+                    save_crop_btn   = gr.Button("✂️  Crop Saddle + Save", variant="primary")
+
+            with gr.Column():
+                tpl_status     = gr.Textbox(label="Status", lines=4)
+                tpl_debug      = gr.Image(label="Layer-1 Debug (crop mode only)")
+                tpl_cropped    = gr.Image(label="Cropped Saddle (crop mode only)")
+
+        save_raw_btn.click(
+            fn=pipeline.add_template,
+            inputs=[tpl_input, tpl_name],
+            outputs=tpl_status,
+            api_name="add_template_raw",
+        )
+        save_crop_btn.click(
+            fn=pipeline.add_template_with_crop,
+            inputs=[tpl_input, tpl_name],
+            outputs=[tpl_status, tpl_debug, tpl_cropped],
+            api_name="add_template_crop",
+        )
+
+    # ── Tab 3: Template Library ────────────────────────────────────────────────
+    with gr.Tab("📋 Template Library"):
+        tpl_list    = gr.Textbox(label="Saved Templates", lines=12)
+        refresh_btn = gr.Button("🔄 Refresh")
+        refresh_btn.click(fn=pipeline.list_templates, outputs=tpl_list)
+        demo.load(fn=pipeline.list_templates, outputs=tpl_list)
+
+    gr.Markdown(
+        """
+        ---
+        **Architecture notes:**  
+        Layer-1 uses an adaptive Y-gap split (largest inter-row gap > 5 % of image height) 
+        rather than K-Means, making it robust to images with varying numbers of bolt holes or 
+        non-uniform spacing.  Line fitting uses scipy OLS regression for stability even when 
+        holes are slightly misaligned.  The per-column mask preserves angled saddles correctly.
+        """
+    )
+
+if __name__ == "__main__":
+    demo.launch(share=False)