feat: multi-object, ORB, evaluation page, feature importance

app.py

@@ -16,26 +16,31 @@ st.divider()
 # ===================================================================
 st.header("🗺️ Pipeline Overview")
 st.markdown("""
-The app is structured as a **5-stage sequential pipeline**.
+The app is structured as a **7-stage sequential pipeline**.
 Complete each page in order — every stage feeds the next.
 """)
 
 stages = [
     ("🧪", "1 · Data Lab",          "Upload a stereo image pair, camera calibration file, and two PFM ground-truth depth maps. "
-                                      "Define an object ROI (bounding box), then apply live data augmentation "
+                                      "Define one or more object ROIs (bounding boxes) with class labels, then apply live data augmentation "
                                       "(brightness, contrast, rotation, noise, blur, shift, flip). "
                                       "All assets are locked into session state — nothing is written to disk."),
     ("🔬", "2 · Feature Lab",        "Toggle RCE physics modules (Intensity · Sobel · Spectral) to build a modular "
                                       "feature vector. Compare it live against CNN activation maps extracted from a "
                                       "frozen backbone via forward hooks. Lock your active module configuration."),
     ("⚙️", "3 · Model Tuning",       "Train lightweight **heads** on your session data (augmented crop = positives, "
-                                      "random non-overlapping patches from the scene = negatives). "
-                                      "Both RCE and CNN heads are trained identically with LogisticRegression "
-                                      "and stored in session state only — no disk writes."),
-    ("🎯", "4 · Real-Time Detection","Run a **sliding window** across the right image using both the RCE head and "
-                                      "your chosen CNN head simultaneously. Watch the scan live, then compare "
-                                      "bounding boxes, confidence heatmaps, and latency."),
-    ("📐", "5 · Stereo Geometry",    "Compute a disparity map with **StereoSGBM**, convert it to metric depth "
+                                      "random non-overlapping patches = negatives). Compare three paradigms side by side: "
+                                      "RCE (with feature importance), CNN (with activation overlay), and ORB (keypoint matching)."),
+    ("🔍", "4 · Localization Lab",   "Compare **five localization strategies** on top of your trained head: "
+                                      "Exhaustive Sliding Window, Image Pyramid (multi-scale), Coarse-to-Fine "
+                                      "hierarchical search, Contour Proposals (edge-driven), and Template "
+                                      "Matching (cross-correlation)."),
+    ("🎯", "5 · Real-Time Detection","Run a **sliding window** across the right image using RCE, CNN, and ORB "
+                                      "simultaneously. Watch the scan live, then compare bounding boxes, "
+                                      "confidence heatmaps, and latency across all three methods."),
+    ("📈", "6 · Evaluation",         "Quantitative evaluation with **confusion matrices**, **precision-recall curves**, "
+                                      "and **F1 scores** per method. Ground truth is derived from your Data Lab ROIs."),
+    ("📐", "7 · Stereo Geometry",    "Compute a disparity map with **StereoSGBM**, convert it to metric depth "
                                       "using the stereo formula $Z = fB/(d+d_{\\text{offs}})$, then read depth "
                                       "directly at every detected bounding box. Compare against PFM ground truth."),
 ]

pages/2_Data_Lab.py

@@ -146,31 +146,85 @@ if up_l and up_r and up_conf and up_gt_l and up_gt_r:
         st.text_area("Raw Config", conf_content, height=200)
 
     # -----------------------------------------------------------------------
-    # Step 3 — Crop ROI from Left Image
+    # Step 3 — Crop ROI(s) from Left Image  (Multi-Object)
     # -----------------------------------------------------------------------
     st.divider()
-    st.subheader("Step 3: Crop Region of Interest")
-    st.write("Define the bounding box of the object you want to recognise (pixels).")
+    st.subheader("Step 3: Crop Region(s) of Interest")
+    st.write("Define one or more bounding boxes — each becomes a separate class for recognition.")
 
     H, W = img_l.shape[:2]
-    cr1, cr2, cr3, cr4 = st.columns(4)
-    x0 = cr1.number_input("X start", 0, W - 2, 0, step=1)
-    y0 = cr2.number_input("Y start", 0, H - 2, 0, step=1)
-    x1 = cr3.number_input("X end",   int(x0) + 1, W, min(W, int(x0) + 100), step=1)
-    y1 = cr4.number_input("Y end",   int(y0) + 1, H, min(H, int(y0) + 100), step=1)
 
-    x0, y0, x1, y1 = int(x0), int(y0), int(x1), int(y1)
-
-    # Overlay rectangle on left image
+    # Manage list of ROIs in session state
+    if "rois" not in st.session_state:
+        st.session_state["rois"] = [{"label": "object", "x0": 0, "y0": 0,
+                                      "x1": min(W, 100), "y1": min(H, 100)}]
+
+    def _add_roi():
+        st.session_state["rois"].append(
+            {"label": f"object_{len(st.session_state['rois'])+1}",
+             "x0": 0, "y0": 0,
+             "x1": min(W, 100), "y1": min(H, 100)})
+
+    def _remove_roi(idx):
+        if len(st.session_state["rois"]) > 1:
+            st.session_state["rois"].pop(idx)
+
+    ROI_COLORS = [(0,255,0), (255,0,0), (0,0,255), (255,255,0),
+                  (255,0,255), (0,255,255), (128,255,0), (255,128,0)]
+
+    for i, roi in enumerate(st.session_state["rois"]):
+        color = ROI_COLORS[i % len(ROI_COLORS)]
+        color_hex = "#{:02x}{:02x}{:02x}".format(*color)
+        with st.container(border=True):
+            hc1, hc2, hc3 = st.columns([3, 6, 1])
+            hc1.markdown(f"**ROI {i+1}** <span style='color:{color_hex}'>■</span>",
+                         unsafe_allow_html=True)
+            roi["label"] = hc2.text_input("Class Label", roi["label"],
+                                           key=f"roi_lbl_{i}")
+            if len(st.session_state["rois"]) > 1:
+                hc3.button("✕", key=f"roi_del_{i}",
+                           on_click=_remove_roi, args=(i,))
+
+            cr1, cr2, cr3, cr4 = st.columns(4)
+            roi["x0"] = int(cr1.number_input("X start", 0, W-2, int(roi["x0"]),
+                                              step=1, key=f"roi_x0_{i}"))
+            roi["y0"] = int(cr2.number_input("Y start", 0, H-2, int(roi["y0"]),
+                                              step=1, key=f"roi_y0_{i}"))
+            roi["x1"] = int(cr3.number_input("X end", roi["x0"]+1, W,
+                                              min(W, int(roi["x1"])),
+                                              step=1, key=f"roi_x1_{i}"))
+            roi["y1"] = int(cr4.number_input("Y end", roi["y0"]+1, H,
+                                              min(H, int(roi["y1"])),
+                                              step=1, key=f"roi_y1_{i}"))
+
+    st.button("➕ Add Another ROI", on_click=_add_roi)
+
+    # Draw all ROIs on the image
     overlay = img_l.copy()
-    cv2.rectangle(overlay, (x0, y0), (x1, y1), (0, 255, 0), 2)
-    crop_bgr = img_l[y0:y1, x0:x1].copy()
-
-    ov1, ov2 = st.columns([3, 1])
+    crops = []
+    for i, roi in enumerate(st.session_state["rois"]):
+        color = ROI_COLORS[i % len(ROI_COLORS)]
+        x0, y0, x1, y1 = roi["x0"], roi["y0"], roi["x1"], roi["y1"]
+        cv2.rectangle(overlay, (x0, y0), (x1, y1), color, 2)
+        cv2.putText(overlay, roi["label"], (x0, y0 - 6),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
+        crops.append(img_l[y0:y1, x0:x1].copy())
+
+    ov1, ov2 = st.columns([3, 2])
     ov1.image(cv2.cvtColor(overlay, cv2.COLOR_BGR2RGB),
-              caption="Left Image — ROI highlighted", use_container_width=True)
-    ov2.image(cv2.cvtColor(crop_bgr, cv2.COLOR_BGR2RGB),
-              caption="Crop", use_container_width=True)
+              caption="Left Image — ROIs highlighted", use_container_width=True)
+    with ov2:
+        for i, (c, roi) in enumerate(zip(crops, st.session_state["rois"])):
+            st.image(cv2.cvtColor(c, cv2.COLOR_BGR2RGB),
+                     caption=f"{roi['label']} ({c.shape[1]}×{c.shape[0]})",
+                     width=160)
+
+    # For backward compatibility: first ROI is the "primary"
+    crop_bgr = crops[0]
+    x0, y0, x1, y1 = (st.session_state["rois"][0]["x0"],
+                       st.session_state["rois"][0]["y0"],
+                       st.session_state["rois"][0]["x1"],
+                       st.session_state["rois"][0]["y1"])
 
     # -----------------------------------------------------------------------
     # Step 4 — Data Augmentation
@@ -195,28 +249,49 @@ if up_l and up_r and up_conf and up_gt_l and up_gt_r:
     aug = augment(crop_bgr, brightness, contrast, rotation,
                   flip_h, flip_v, noise, blur, shift_x, shift_y)
 
+    # Apply same augmentation to all crops
+    all_augs = [augment(c, brightness, contrast, rotation,
+                        flip_h, flip_v, noise, blur, shift_x, shift_y)
+                for c in crops]
+
     aug_col1, aug_col2 = st.columns(2)
     aug_col1.image(cv2.cvtColor(crop_bgr, cv2.COLOR_BGR2RGB),
-                   caption="Original Crop", use_container_width=True)
+                   caption="Original Crop (ROI 1)", use_container_width=True)
     aug_col2.image(cv2.cvtColor(aug, cv2.COLOR_BGR2RGB),
-                   caption="Augmented Crop", use_container_width=True)
+                   caption="Augmented Crop (ROI 1)", use_container_width=True)
+
+    if len(crops) > 1:
+        st.caption(f"Augmentation applied identically to all {len(crops)} ROIs.")
 
     # -----------------------------------------------------------------------
     # Step 5 — Lock & Store
     # -----------------------------------------------------------------------
     st.divider()
     if st.button("🚀 Lock Data & Proceed to Benchmark"):
+        rois_data = []
+        for i, roi in enumerate(st.session_state["rois"]):
+            rois_data.append({
+                "label":    roi["label"],
+                "bbox":     (roi["x0"], roi["y0"], roi["x1"], roi["y1"]),
+                "crop":     crops[i],
+                "crop_aug": all_augs[i],
+            })
+
         st.session_state["pipeline_data"] = {
             "left":       img_l,
             "right":      img_r,
             "gt_left":    gt_depth_l,
             "gt_right":   gt_depth_r,
             "conf_raw":   conf_content,
+            # Backward compatibility: first ROI
             "crop":       crop_bgr,
             "crop_aug":   aug,
             "crop_bbox":  (x0, y0, x1, y1),
+            # Multi-object
+            "rois":       rois_data,
         }
-        st.success("Data stored in session! Move to the 'Recognition' or 'Tuning' page.")
+        st.success(f"Data stored with **{len(rois_data)} ROI(s)**! "
+                   f"Move to Feature Lab.")
 
 else:
     st.info("Please upload all 5 files (left image, right image, config, left GT, right GT) to proceed.")

pages/4_Model_Tuning.py

@@ -20,41 +20,52 @@ if "pipeline_data" not in st.session_state or "crop" not in st.session_state.get
     st.stop()
 
 assets = st.session_state["pipeline_data"]
-crop      = assets["crop"]           # original crop from Data Lab
-crop_aug  = assets.get("crop_aug", crop)  # augmented crop from Data Lab
-left_img  = assets["left"]           # full left image
+crop      = assets["crop"]
+crop_aug  = assets.get("crop_aug", crop)
+left_img  = assets["left"]
 bbox      = assets.get("crop_bbox", (0, 0, crop.shape[1], crop.shape[0]))
+rois      = assets.get("rois", [{"label": "object", "bbox": bbox,
+                                  "crop": crop, "crop_aug": crop_aug}])
 active_modules = st.session_state.get("active_modules", {k: True for k in REGISTRY})
 
+is_multi = len(rois) > 1
 
 # ---------------------------------------------------------------------------
 # Build training set from session data (no disk reads)
 # ---------------------------------------------------------------------------
-def build_training_set(augment_fn=None):
+def build_training_set():
     """
-    Positive samples:  original crop + augmented crop from Data Lab.
-    Negative samples:  random patches from the left image that do NOT
-                       overlap with the crop bounding box.
-    Returns (images_list, labels_list).
+    Multi-class aware training set builder.
+    Positive samples per class: original crop + augmented crop.
+    Negative samples: random patches that don't overlap ANY ROI.
     """
-    positives = [crop, crop_aug]
-    if augment_fn is not None:
-        positives.append(augment_fn(crop))
+    images = []
+    labels = []
 
-    # --- Generate negatives from left image margins ---
-    x0, y0, x1, y1 = bbox
+    for roi in rois:
+        images.append(roi["crop"])
+        labels.append(roi["label"])
+        images.append(roi["crop_aug"])
+        labels.append(roi["label"])
+
+    all_bboxes = [roi["bbox"] for roi in rois]
     H, W = left_img.shape[:2]
-    ch, cw = y1 - y0, x1 - x0  # crop height/width
-    negatives = []
+    x0r, y0r, x1r, y1r = rois[0]["bbox"]
+    ch, cw = y1r - y0r, x1r - x0r
     rng = np.random.default_rng(42)
 
+    n_neg_target = len(images) * 2
     attempts = 0
-    while len(negatives) < len(positives) * 2 and attempts < 200:
-        # Random patch of same size as crop
+    negatives = []
+    while len(negatives) < n_neg_target and attempts < 300:
         rx = rng.integers(0, max(W - cw, 1))
         ry = rng.integers(0, max(H - ch, 1))
-        # Reject if it overlaps the crop bbox (IoU > 0)
-        if rx < x1 and rx + cw > x0 and ry < y1 and ry + ch > y0:
+        overlaps = False
+        for bx0, by0, bx1, by1 in all_bboxes:
+            if rx < bx1 and rx + cw > bx0 and ry < by1 and ry + ch > by0:
+                overlaps = True
+                break
+        if overlaps:
             attempts += 1
             continue
         patch = left_img[ry:ry+ch, rx:rx+cw]
@@ -62,13 +73,12 @@ def build_training_set(augment_fn=None):
             negatives.append(patch)
         attempts += 1
 
-    images = positives + negatives
-    labels = ["object"] * len(positives) + ["background"] * len(negatives)
+    images.extend(negatives)
+    labels.extend(["background"] * len(negatives))
     return images, labels
 
 
 def build_rce_vector(img_bgr):
-    """Build the RCE feature vector from active modules."""
     gray = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)
     vec = []
     for key, meta in REGISTRY.items():
@@ -79,20 +89,31 @@ def build_rce_vector(img_bgr):
 
 
 # ===================================================================
-# Show data used for training
+# Show training data
 # ===================================================================
 st.subheader("Training Data (from Data Lab)")
-st.caption("Positives = your crop + augmented crop  |  Negatives = random non-overlapping patches from left image")
-td1, td2 = st.columns(2)
-td1.image(cv2.cvtColor(crop, cv2.COLOR_BGR2RGB), caption="Original Crop (positive)", width=180)
-td2.image(cv2.cvtColor(crop_aug, cv2.COLOR_BGR2RGB), caption="Augmented Crop (positive)", width=180)
+if is_multi:
+    st.caption(f"**{len(rois)} classes** defined — each ROI becomes a separate class.")
+    roi_cols = st.columns(min(len(rois), 4))
+    for i, roi in enumerate(rois):
+        with roi_cols[i % len(roi_cols)]:
+            st.image(cv2.cvtColor(roi["crop"], cv2.COLOR_BGR2RGB),
+                     caption=f"✅ {roi['label']}", width=140)
+else:
+    st.caption("Positives = your crop + augmented crop  |  "
+               "Negatives = random non-overlapping patches")
+    td1, td2 = st.columns(2)
+    td1.image(cv2.cvtColor(crop, cv2.COLOR_BGR2RGB),
+              caption="Original Crop (positive)", width=180)
+    td2.image(cv2.cvtColor(crop_aug, cv2.COLOR_BGR2RGB),
+              caption="Augmented Crop (positive)", width=180)
 
 st.divider()
 
 # ===================================================================
-# LAYOUT: LEFT = RCE  |  RIGHT = CNN
+# LAYOUT: RCE  |  CNN  |  ORB
 # ===================================================================
-col_rce, col_cnn = st.columns(2)
+col_rce, col_cnn, col_orb = st.columns(3)
 
 # ---------------------------------------------------------------------------
 # LEFT — RCE Training
@@ -103,68 +124,121 @@ with col_rce:
     active_names = [REGISTRY[k]["label"] for k in active_modules if active_modules[k]]
     if not active_names:
         st.error("No RCE modules selected. Go back to Feature Lab.")
-        st.stop()
-    st.write(f"**Active modules:** {', '.join(active_names)}")
-
-    st.subheader("Training Parameters")
-    rce_C = st.slider("Regularization (C)", 0.01, 10.0, 1.0, step=0.01,
-                       help="Higher = less regularization, may overfit")
-    rce_max_iter = st.slider("Max Iterations", 100, 5000, 1000, step=100)
-
-    if st.button("🚀 Train RCE Head"):
-        images, labels = build_training_set()
-        from sklearn.metrics import accuracy_score
-
-        progress = st.progress(0, text="Extracting RCE features...")
-        n = len(images)
-        X = []
-        for i, img in enumerate(images):
-            X.append(build_rce_vector(img))
-            progress.progress((i + 1) / n, text=f"Feature extraction: {i+1}/{n}")
-
-        X = np.array(X)
-        progress.progress(1.0, text="Fitting Logistic Regression...")
-
-        t0 = time.perf_counter()
-        head = RecognitionHead(C=rce_C, max_iter=rce_max_iter).fit(X, labels)
-        train_time = time.perf_counter() - t0
-        progress.progress(1.0, text="✅ Training complete!")
-
-        preds = head.model.predict(X)
-        train_acc = accuracy_score(labels, preds)
-
-        st.success(f"Trained in **{train_time:.2f}s**")
-        m1, m2, m3 = st.columns(3)
-        m1.metric("Train Accuracy", f"{train_acc:.1%}")
-        m2.metric("Vector Size", f"{X.shape[1]} floats")
-        m3.metric("Samples", f"{len(images)}")
-
-        probs = head.predict_proba(X)
-        fig = go.Figure()
-        for ci, cls in enumerate(head.classes_):
-            fig.add_trace(go.Histogram(x=probs[:, ci], name=cls, opacity=0.7, nbinsx=20))
-        fig.update_layout(title="Confidence Distribution", barmode="overlay",
-                          template="plotly_dark", height=280,
-                          xaxis_title="Confidence", yaxis_title="Count")
-        st.plotly_chart(fig, use_container_width=True)
-
-        # Store head in session (no disk save)
-        st.session_state["rce_head"] = head
-        st.session_state["rce_train_acc"] = train_acc
-
-    if "rce_head" in st.session_state:
-        st.divider()
-        st.subheader("Quick Predict (Crop)")
-        head = st.session_state["rce_head"]
-        t0 = time.perf_counter()
-        vec = build_rce_vector(crop_aug)
-        label, conf = head.predict(vec)
-        dt = (time.perf_counter() - t0) * 1000
-        st.write(f"**{label}** — {conf:.1%} confidence — {dt:.1f} ms")
+    else:
+        st.write(f"**Active modules:** {', '.join(active_names)}")
+
+        st.subheader("Training Parameters")
+        rce_C = st.slider("Regularization (C)", 0.01, 10.0, 1.0, step=0.01,
+                           help="Higher = less regularization, may overfit")
+        rce_max_iter = st.slider("Max Iterations", 100, 5000, 1000, step=100)
+
+        if st.button("🚀 Train RCE Head"):
+            images, labels = build_training_set()
+            from sklearn.metrics import accuracy_score
+
+            progress = st.progress(0, text="Extracting RCE features...")
+            n = len(images)
+            X = []
+            for i, img in enumerate(images):
+                X.append(build_rce_vector(img))
+                progress.progress((i + 1) / n, text=f"Feature extraction: {i+1}/{n}")
+
+            X = np.array(X)
+            progress.progress(1.0, text="Fitting Logistic Regression...")
+
+            t0 = time.perf_counter()
+            head = RecognitionHead(C=rce_C, max_iter=rce_max_iter).fit(X, labels)
+            train_time = time.perf_counter() - t0
+            progress.progress(1.0, text="✅ Training complete!")
+
+            preds = head.model.predict(X)
+            train_acc = accuracy_score(labels, preds)
+
+            st.success(f"Trained in **{train_time:.2f}s**")
+            m1, m2, m3 = st.columns(3)
+            m1.metric("Train Accuracy", f"{train_acc:.1%}")
+            m2.metric("Vector Size", f"{X.shape[1]} floats")
+            m3.metric("Samples", f"{len(images)}")
+            if is_multi:
+                st.caption(f"Classes: {', '.join(head.classes_)}")
+
+            probs = head.predict_proba(X)
+            fig = go.Figure()
+            for ci, cls in enumerate(head.classes_):
+                fig.add_trace(go.Histogram(x=probs[:, ci], name=cls,
+                                           opacity=0.7, nbinsx=20))
+            fig.update_layout(title="Confidence Distribution", barmode="overlay",
+                              template="plotly_dark", height=280,
+                              xaxis_title="Confidence", yaxis_title="Count")
+            st.plotly_chart(fig, use_container_width=True)
+
+            # ---- Feature Importance (RCE) ----
+            st.subheader("🔍 Feature Importance")
+            coefs = head.model.coef_
+            feat_names = []
+            for key, meta_r in REGISTRY.items():
+                if active_modules.get(key, False):
+                    for b in range(10):
+                        feat_names.append(f"{meta_r['label']}[{b}]")
+
+            if coefs.shape[0] == 1:
+                importance = np.abs(coefs[0])
+                fig_imp = go.Figure(go.Bar(
+                    x=feat_names, y=importance,
+                    marker_color=["#00d4ff" if "Intensity" in fn
+                                  else "#ff6600" if "Sobel" in fn
+                                  else "#aa00ff" for fn in feat_names]))
+                fig_imp.update_layout(title="LogReg Coefficient Magnitude",
+                                      template="plotly_dark", height=300,
+                                      xaxis_title="Feature", yaxis_title="|Coefficient|")
+            else:
+                fig_imp = go.Figure()
+                for ci, cls in enumerate(head.classes_):
+                    if cls == "background":
+                        continue
+                    fig_imp.add_trace(go.Bar(
+                        x=feat_names, y=np.abs(coefs[ci]),
+                        name=cls, opacity=0.8))
+                fig_imp.update_layout(title="LogReg Coefficients per Class",
+                                      template="plotly_dark", height=300,
+                                      barmode="group",
+                                      xaxis_title="Feature", yaxis_title="|Coefficient|")
+            st.plotly_chart(fig_imp, use_container_width=True)
+
+            # Module-level aggregation
+            module_importance = {}
+            idx = 0
+            for key, meta_r in REGISTRY.items():
+                if active_modules.get(key, False):
+                    module_importance[meta_r["label"]] = float(
+                        np.abs(coefs[:, idx:idx+10]).mean())
+                    idx += 10
+
+            if module_importance:
+                fig_mod = go.Figure(go.Pie(
+                    labels=list(module_importance.keys()),
+                    values=list(module_importance.values()),
+                    hole=0.4))
+                fig_mod.update_layout(title="Module Contribution (avg |coef|)",
+                                      template="plotly_dark", height=280)
+                st.plotly_chart(fig_mod, use_container_width=True)
+
+            st.session_state["rce_head"] = head
+            st.session_state["rce_train_acc"] = train_acc
+
+        if "rce_head" in st.session_state:
+            st.divider()
+            st.subheader("Quick Predict (Crop)")
+            head = st.session_state["rce_head"]
+            t0 = time.perf_counter()
+            vec = build_rce_vector(crop_aug)
+            label, conf = head.predict(vec)
+            dt = (time.perf_counter() - t0) * 1000
+            st.write(f"**{label}** — {conf:.1%} confidence — {dt:.1f} ms")
 
 
 # ---------------------------------------------------------------------------
-# RIGHT — CNN Fine-Tuning
+# MIDDLE — CNN Fine-Tuning
 # ---------------------------------------------------------------------------
 with col_cnn:
     st.header("🧠 CNN Fine-Tuning")
@@ -181,7 +255,7 @@ with col_cnn:
 
     if st.button(f"🚀 Train {selected} Head"):
         images, labels = build_training_set()
-        backbone = meta["loader"]()          # cached frozen backbone
+        backbone = meta["loader"]()
 
         from sklearn.metrics import accuracy_score
 
@@ -208,24 +282,46 @@ with col_cnn:
         m1.metric("Train Accuracy", f"{train_acc:.1%}")
         m2.metric("Vector Size", f"{X.shape[1]}D")
         m3.metric("Samples", f"{len(images)}")
+        if is_multi:
+            st.caption(f"Classes: {', '.join(head.classes_)}")
 
         probs = head.predict_proba(X)
         fig = go.Figure()
         for ci, cls in enumerate(head.classes_):
-            fig.add_trace(go.Histogram(x=probs[:, ci], name=cls, opacity=0.7, nbinsx=20))
+            fig.add_trace(go.Histogram(x=probs[:, ci], name=cls,
+                                       opacity=0.7, nbinsx=20))
         fig.update_layout(title="Confidence Distribution", barmode="overlay",
                           template="plotly_dark", height=280,
                           xaxis_title="Confidence", yaxis_title="Count")
         st.plotly_chart(fig, use_container_width=True)
 
-        # Store head in session (no disk save)
+        # ---- Activation Overlay (Grad-CAM style) ----
+        st.subheader("🔍 Activation Overlay")
+        st.caption("Highest-activation spatial regions from the hooked layer, "
+                   "overlaid on the crop as a Grad-CAM–style heatmap.")
+        try:
+            act_maps = backbone.get_activation_maps(crop_aug, n_maps=1)
+            if act_maps:
+                cam = act_maps[0]
+                cam_resized = cv2.resize(cam, (crop_aug.shape[1], crop_aug.shape[0]))
+                cam_color = cv2.applyColorMap(
+                    (cam_resized * 255).astype(np.uint8), cv2.COLORMAP_JET)
+                overlay_img = cv2.addWeighted(crop_aug, 0.5, cam_color, 0.5, 0)
+                gc1, gc2 = st.columns(2)
+                gc1.image(cv2.cvtColor(crop_aug, cv2.COLOR_BGR2RGB),
+                          caption="Input Crop", use_container_width=True)
+                gc2.image(cv2.cvtColor(overlay_img, cv2.COLOR_BGR2RGB),
+                          caption="Activation Overlay", use_container_width=True)
+        except Exception:
+            pass
+
         st.session_state[f"cnn_head_{selected}"] = head
         st.session_state[f"cnn_acc_{selected}"] = train_acc
 
     if f"cnn_head_{selected}" in st.session_state:
         st.divider()
         st.subheader("Quick Predict (Crop)")
-        backbone = meta["loader"]()          # cached frozen backbone
+        backbone = meta["loader"]()
         head = st.session_state[f"cnn_head_{selected}"]
         t0 = time.perf_counter()
         feats = backbone.get_features(crop_aug)
@@ -234,22 +330,110 @@ with col_cnn:
         st.write(f"**{label}** — {conf:.1%} confidence — {dt:.1f} ms")
 
 
+# ---------------------------------------------------------------------------
+# RIGHT — ORB Training
+# ---------------------------------------------------------------------------
+with col_orb:
+    st.header("🏛️ ORB Matching")
+    st.caption("Keypoint-based matching — a fundamentally different paradigm. "
+               "Extracts ORB descriptors from each ROI crop and matches them "
+               "against image patches using brute-force Hamming distance.")
+
+    from src.detectors.orb import ORBDetector
+
+    orb_dist_thresh = st.slider("Match Distance Threshold", 10, 100, 70,
+                                 key="orb_dist")
+    orb_min_matches = st.slider("Min Good Matches", 1, 20, 5, key="orb_min")
+
+    if st.button("🚀 Train ORB Reference"):
+        orb = ORBDetector()
+        progress = st.progress(0, text="Extracting ORB descriptors...")
+
+        orb_refs = {}
+        for i, roi in enumerate(rois):
+            gray = cv2.cvtColor(roi["crop_aug"], cv2.COLOR_BGR2GRAY)
+            clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+            gray = clahe.apply(gray)
+            kp, des = orb.orb.detectAndCompute(gray, None)
+            n_feat = 0 if des is None else len(des)
+            orb_refs[roi["label"]] = {
+                "descriptors": des,
+                "n_features":  n_feat,
+                "keypoints":   kp,
+                "crop":        roi["crop_aug"],
+            }
+            progress.progress((i + 1) / len(rois),
+                              text=f"ROI {i+1}/{len(rois)}: {n_feat} features")
+
+        progress.progress(1.0, text="✅ ORB references extracted!")
+
+        for lbl, ref in orb_refs.items():
+            if ref["keypoints"]:
+                vis = cv2.drawKeypoints(ref["crop"], ref["keypoints"],
+                                         None, color=(0, 255, 0))
+                st.image(cv2.cvtColor(vis, cv2.COLOR_BGR2RGB),
+                         caption=f"{lbl}: {ref['n_features']} keypoints",
+                         use_container_width=True)
+            else:
+                st.warning(f"{lbl}: No keypoints detected")
+
+        st.session_state["orb_detector"] = orb
+        st.session_state["orb_refs"] = orb_refs
+        st.session_state["orb_dist_thresh"] = orb_dist_thresh
+        st.session_state["orb_min_matches"] = orb_min_matches
+        st.success("ORB references stored in session!")
+
+    if "orb_refs" in st.session_state:
+        st.divider()
+        st.subheader("Quick Predict (Crop)")
+        orb = st.session_state["orb_detector"]
+        refs = st.session_state["orb_refs"]
+        dt_thresh = st.session_state["orb_dist_thresh"]
+        min_m = st.session_state["orb_min_matches"]
+
+        gray = cv2.cvtColor(crop_aug, cv2.COLOR_BGR2GRAY)
+        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+        gray = clahe.apply(gray)
+        kp, des = orb.orb.detectAndCompute(gray, None)
+
+        if des is not None:
+            for lbl, ref in refs.items():
+                if ref["descriptors"] is None:
+                    st.write(f"**{lbl}:** no reference features")
+                    continue
+                matches = orb.bf.match(ref["descriptors"], des)
+                good = [m for m in matches if m.distance < dt_thresh]
+                conf = min(len(good) / max(min_m, 1), 1.0)
+                verdict = lbl if len(good) >= min_m else "background"
+                st.write(f"**{verdict}** — {len(good)} matches — "
+                         f"{conf:.0%} confidence")
+        else:
+            st.write("No keypoints in test image.")
+
+
 # ===========================================================================
 # Bottom — Side-by-side comparison table
 # ===========================================================================
 st.divider()
 st.subheader("📊 Training Comparison")
 
-rce_acc = st.session_state.get("rce_train_acc")
 rows = []
+rce_acc = st.session_state.get("rce_train_acc")
 if rce_acc is not None:
-    rows.append({"Model": "RCE", "Train Accuracy": f"{rce_acc:.1%}",
+    rows.append({"Model": "RCE", "Type": "Feature Engineering",
+                 "Train Accuracy": f"{rce_acc:.1%}",
                  "Vector Size": str(sum(10 for k in active_modules if active_modules[k]))})
 for name in BACKBONES:
     acc = st.session_state.get(f"cnn_acc_{name}")
     if acc is not None:
-        rows.append({"Model": name, "Train Accuracy": f"{acc:.1%}",
+        rows.append({"Model": name, "Type": "CNN Backbone",
+                     "Train Accuracy": f"{acc:.1%}",
                      "Vector Size": f"{BACKBONES[name]['dim']}D"})
+if "orb_refs" in st.session_state:
+    total_kp = sum(r["n_features"] for r in st.session_state["orb_refs"].values())
+    rows.append({"Model": "ORB", "Type": "Keypoint Matching",
+                 "Train Accuracy": "N/A (matching)",
+                 "Vector Size": f"{total_kp} descriptors"})
 
 if rows:
     import pandas as pd

pages/5_Localization_Lab.py

@@ -0,0 +1,348 @@
+import streamlit as st
+import cv2
+import numpy as np
+import pandas as pd
+import plotly.graph_objects as go
+import sys, os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from src.detectors.rce.features import REGISTRY
+from src.models import BACKBONES, RecognitionHead
+from src.localization import (
+    exhaustive_sliding_window,
+    image_pyramid,
+    coarse_to_fine,
+    contour_proposals,
+    template_matching,
+    STRATEGIES,
+)
+
+st.set_page_config(page_title="Localization Lab", layout="wide")
+st.title("🔍 Localization Lab")
+st.markdown(
+    "Compare **localization strategies** — algorithms that decide *where* "
+    "to look in the image.  The recognition head stays the same; only the "
+    "search method changes."
+)
+
+# ===================================================================
+#  Guard
+# ===================================================================
+if "pipeline_data" not in st.session_state or \
+        "crop" not in st.session_state.get("pipeline_data", {}):
+    st.error("Complete **Data Lab** first (upload assets & define a crop).")
+    st.stop()
+
+assets    = st.session_state["pipeline_data"]
+right_img = assets["right"]
+crop      = assets["crop"]
+crop_aug  = assets.get("crop_aug", crop)
+bbox      = assets.get("crop_bbox", (0, 0, crop.shape[1], crop.shape[0]))
+active_mods = st.session_state.get("active_modules",
+                                    {k: True for k in REGISTRY})
+
+x0, y0, x1, y1 = bbox
+win_h, win_w = y1 - y0, x1 - x0
+
+rce_head    = st.session_state.get("rce_head")
+has_any_cnn = any(f"cnn_head_{n}" in st.session_state for n in BACKBONES)
+
+if rce_head is None and not has_any_cnn:
+    st.warning("No trained heads found.  Go to **Model Tuning** first.")
+    st.stop()
+
+
+# ===================================================================
+#  RCE feature function
+# ===================================================================
+def rce_feature_fn(patch_bgr):
+    gray = cv2.cvtColor(patch_bgr, cv2.COLOR_BGR2GRAY)
+    vec = []
+    for key, meta in REGISTRY.items():
+        if active_mods.get(key, False):
+            v, _ = meta["fn"](gray)
+            vec.extend(v)
+    return np.array(vec, dtype=np.float32)
+
+
+# ===================================================================
+#  Algorithm Reference  (collapsible)
+# ===================================================================
+st.divider()
+with st.expander("📚 **Algorithm Reference** — click to expand", expanded=False):
+    tabs = st.tabs([f"{v['icon']} {k}" for k, v in STRATEGIES.items()])
+    for tab, (name, meta) in zip(tabs, STRATEGIES.items()):
+        with tab:
+            st.markdown(f"### {meta['icon']}  {name}")
+            st.caption(meta["short"])
+            st.markdown(meta["detail"])
+
+
+# ===================================================================
+#  Configuration
+# ===================================================================
+st.divider()
+st.header("⚙️ Configuration")
+
+# --- Head selection ---
+col_head, col_info = st.columns([2, 3])
+with col_head:
+    head_options = []
+    if rce_head is not None:
+        head_options.append("RCE")
+    trained_cnns = [n for n in BACKBONES if f"cnn_head_{n}" in st.session_state]
+    head_options.extend(trained_cnns)
+    selected_head = st.selectbox("Recognition Head", head_options,
+                                  key="loc_head")
+
+if selected_head == "RCE":
+    feature_fn = rce_feature_fn
+    head = rce_head
+else:
+    bmeta    = BACKBONES[selected_head]
+    backbone = bmeta["loader"]()
+    feature_fn = backbone.get_features
+    head = st.session_state[f"cnn_head_{selected_head}"]
+
+with col_info:
+    if selected_head == "RCE":
+        mods = [REGISTRY[k]["label"] for k in active_mods if active_mods[k]]
+        st.info(f"**RCE** — Modules: {', '.join(mods)}")
+    else:
+        st.info(f"**{selected_head}** — "
+                f"{BACKBONES[selected_head]['dim']}D feature vector")
+
+# --- Algorithm checkboxes ---
+st.subheader("Select Algorithms to Compare")
+algo_cols = st.columns(5)
+algo_names = list(STRATEGIES.keys())
+algo_checks = {}
+for col, name in zip(algo_cols, algo_names):
+    algo_checks[name] = col.checkbox(
+        f"{STRATEGIES[name]['icon']} {name}",
+        value=(name != "Template Matching"),     # default all on except TM
+        key=f"chk_{name}")
+
+any_selected = any(algo_checks.values())
+
+# --- Shared parameters ---
+st.subheader("Parameters")
+sp1, sp2, sp3 = st.columns(3)
+stride      = sp1.slider("Base Stride (px)", 4, max(win_w, win_h),
+                          max(win_w // 4, 4), step=2, key="loc_stride")
+conf_thresh = sp2.slider("Confidence Threshold", 0.5, 1.0, 0.7, 0.05,
+                          key="loc_conf")
+nms_iou     = sp3.slider("NMS IoU Threshold", 0.1, 0.9, 0.3, 0.05,
+                          key="loc_nms")
+
+# --- Per-algorithm settings ---
+with st.expander("🔧 Per-Algorithm Settings"):
+    pa1, pa2, pa3 = st.columns(3)
+    with pa1:
+        st.markdown("**Image Pyramid**")
+        pyr_min  = st.slider("Min Scale", 0.3, 1.0, 0.5, 0.05, key="pyr_min")
+        pyr_max  = st.slider("Max Scale", 1.0, 2.0, 1.5, 0.1,  key="pyr_max")
+        pyr_n    = st.slider("Number of Scales", 3, 7, 5,       key="pyr_n")
+    with pa2:
+        st.markdown("**Coarse-to-Fine**")
+        c2f_factor = st.slider("Coarse Factor", 2, 8, 4,        key="c2f_factor")
+        c2f_radius = st.slider("Refine Radius (strides)", 1, 5, 2,
+                               key="c2f_radius")
+    with pa3:
+        st.markdown("**Contour Proposals**")
+        cnt_low  = st.slider("Canny Low",  10, 100, 50,         key="cnt_low")
+        cnt_high = st.slider("Canny High", 50, 300, 150,        key="cnt_high")
+        cnt_tol  = st.slider("Area Tolerance", 1.5, 10.0, 3.0, 0.5,
+                             key="cnt_tol")
+
+st.caption(
+    f"Window: **{win_w}×{win_h} px**  ·  "
+    f"Image: **{right_img.shape[1]}×{right_img.shape[0]} px**  ·  "
+    f"Stride: **{stride} px**"
+)
+
+
+# ===================================================================
+#  Run
+# ===================================================================
+st.divider()
+run_btn = st.button("▶  Run Comparison", type="primary",
+                     disabled=not any_selected, use_container_width=True)
+
+if run_btn:
+    selected_algos = [n for n in algo_names if algo_checks[n]]
+    progress = st.progress(0, text="Starting…")
+    results = {}
+    edge_maps = {}                        # for contour visualisation
+
+    for i, name in enumerate(selected_algos):
+        progress.progress(i / len(selected_algos), text=f"Running **{name}**…")
+
+        if name == "Exhaustive Sliding Window":
+            dets, n, ms, hmap = exhaustive_sliding_window(
+                right_img, win_h, win_w, feature_fn, head,
+                stride, conf_thresh, nms_iou)
+
+        elif name == "Image Pyramid":
+            scales = np.linspace(pyr_min, pyr_max, pyr_n).tolist()
+            dets, n, ms, hmap = image_pyramid(
+                right_img, win_h, win_w, feature_fn, head,
+                stride, conf_thresh, nms_iou, scales=scales)
+
+        elif name == "Coarse-to-Fine":
+            dets, n, ms, hmap = coarse_to_fine(
+                right_img, win_h, win_w, feature_fn, head,
+                stride, conf_thresh, nms_iou,
+                coarse_factor=c2f_factor, refine_radius=c2f_radius)
+
+        elif name == "Contour Proposals":
+            dets, n, ms, hmap, edges = contour_proposals(
+                right_img, win_h, win_w, feature_fn, head,
+                conf_thresh, nms_iou,
+                canny_low=cnt_low, canny_high=cnt_high,
+                area_tolerance=cnt_tol)
+            edge_maps[name] = edges
+
+        elif name == "Template Matching":
+            dets, n, ms, hmap = template_matching(
+                right_img, crop_aug, conf_thresh, nms_iou)
+
+        results[name] = {
+            "dets": dets, "n_proposals": n,
+            "time_ms": ms, "heatmap": hmap,
+        }
+
+    progress.progress(1.0, text="Done!")
+
+    # ===============================================================
+    #  Summary Table
+    # ===============================================================
+    st.header("📊 Results")
+
+    baseline_ms = results.get("Exhaustive Sliding Window", {}).get("time_ms")
+    rows = []
+    for name, r in results.items():
+        speedup = (baseline_ms / r["time_ms"]
+                   if baseline_ms and r["time_ms"] > 0 else None)
+        rows.append({
+            "Algorithm":   name,
+            "Proposals":   r["n_proposals"],
+            "Time (ms)":   round(r["time_ms"], 1),
+            "Detections":  len(r["dets"]),
+            "ms / Proposal": round(r["time_ms"] / max(r["n_proposals"], 1), 4),
+            "Speedup": f"{speedup:.1f}×" if speedup else "—",
+        })
+
+    st.dataframe(pd.DataFrame(rows), use_container_width=True, hide_index=True)
+
+    # ===============================================================
+    #  Detection Images & Heatmaps  (one tab per algorithm)
+    # ===============================================================
+    st.subheader("Detection Results")
+    COLORS = {
+        "Exhaustive Sliding Window": (0, 255, 0),
+        "Image Pyramid":             (255, 128, 0),
+        "Coarse-to-Fine":            (0, 128, 255),
+        "Contour Proposals":         (255, 0, 255),
+        "Template Matching":         (0, 255, 255),
+    }
+
+    result_tabs = st.tabs(
+        [f"{STRATEGIES[n]['icon']} {n}" for n in results])
+
+    for tab, (name, r) in zip(result_tabs, results.items()):
+        with tab:
+            c1, c2 = st.columns(2)
+            color = COLORS.get(name, (0, 255, 0))
+
+            # --- Detection overlay ---
+            vis = right_img.copy()
+            for x1d, y1d, x2d, y2d, _, cf in r["dets"]:
+                cv2.rectangle(vis, (x1d, y1d), (x2d, y2d), color, 2)
+                cv2.putText(vis, f"{cf:.0%}", (x1d, y1d - 6),
+                            cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
+            c1.image(cv2.cvtColor(vis, cv2.COLOR_BGR2RGB),
+                     caption=f"{name} — {len(r['dets'])} detections",
+                     use_container_width=True)
+
+            # --- Heatmap ---
+            hmap = r["heatmap"]
+            if hmap.max() > 0:
+                hmap_color = cv2.applyColorMap(
+                    (hmap / hmap.max() * 255).astype(np.uint8),
+                    cv2.COLORMAP_JET)
+                blend = cv2.addWeighted(right_img, 0.5, hmap_color, 0.5, 0)
+                c2.image(cv2.cvtColor(blend, cv2.COLOR_BGR2RGB),
+                         caption=f"{name} — Confidence Heatmap",
+                         use_container_width=True)
+            else:
+                c2.info("No positive responses above threshold.")
+
+            # --- Contour edge map (extra) ---
+            if name in edge_maps:
+                st.image(edge_maps[name],
+                         caption="Canny Edge Map (proposals derived from these contours)",
+                         use_container_width=True, clamp=True)
+
+            # --- Per-algorithm metrics ---
+            m1, m2, m3, m4 = st.columns(4)
+            m1.metric("Proposals",  r["n_proposals"])
+            m2.metric("Time",       f"{r['time_ms']:.0f} ms")
+            m3.metric("Detections", len(r["dets"]))
+            m4.metric("ms / Proposal",
+                      f"{r['time_ms'] / max(r['n_proposals'], 1):.3f}")
+
+            # --- Detection table ---
+            if r["dets"]:
+                df = pd.DataFrame(r["dets"],
+                                  columns=["x1","y1","x2","y2","label","conf"])
+                st.dataframe(df, use_container_width=True, hide_index=True)
+
+    # ===============================================================
+    #  Performance Charts
+    # ===============================================================
+    st.subheader("📈 Performance Comparison")
+    ch1, ch2 = st.columns(2)
+
+    names  = list(results.keys())
+    times  = [results[n]["time_ms"]    for n in names]
+    props  = [results[n]["n_proposals"] for n in names]
+    n_dets = [len(results[n]["dets"])  for n in names]
+    colors_hex = ["#00cc66", "#ff8800", "#0088ff", "#ff00ff", "#00cccc"]
+
+    with ch1:
+        fig = go.Figure(go.Bar(
+            x=names, y=times,
+            text=[f"{t:.0f}" for t in times], textposition="auto",
+            marker_color=colors_hex[:len(names)]))
+        fig.update_layout(title="Total Time (ms)",
+                          yaxis_title="ms", height=400)
+        st.plotly_chart(fig, use_container_width=True)
+
+    with ch2:
+        fig = go.Figure(go.Bar(
+            x=names, y=props,
+            text=[str(p) for p in props], textposition="auto",
+            marker_color=colors_hex[:len(names)]))
+        fig.update_layout(title="Proposals Evaluated",
+                          yaxis_title="Count", height=400)
+        st.plotly_chart(fig, use_container_width=True)
+
+    # --- Scatter: proposals vs time (marker = detections) ---
+    fig = go.Figure()
+    for i, name in enumerate(names):
+        fig.add_trace(go.Scatter(
+            x=[props[i]], y=[times[i]],
+            mode="markers+text",
+            marker=dict(size=max(n_dets[i] * 12, 18),
+                        color=colors_hex[i % len(colors_hex)]),
+            text=[name], textposition="top center",
+            name=name,
+        ))
+    fig.update_layout(
+        title="Proposals vs Time  (marker size ∝ detections)",
+        xaxis_title="Proposals Evaluated",
+        yaxis_title="Time (ms)",
+        height=500,
+    )
+    st.plotly_chart(fig, use_container_width=True)

pages/{5_RealTime_Detection.py → 6_RealTime_Detection.py}

@@ -24,15 +24,22 @@ right_img    = assets["right"]
 crop         = assets["crop"]
 crop_aug     = assets.get("crop_aug", crop)
 bbox         = assets.get("crop_bbox", (0, 0, crop.shape[1], crop.shape[0]))
+rois         = assets.get("rois", [{"label": "object", "bbox": bbox,
+                                    "crop": crop, "crop_aug": crop_aug}])
 active_mods  = st.session_state.get("active_modules", {k: True for k in REGISTRY})
 
 x0, y0, x1, y1 = bbox
 win_h, win_w = y1 - y0, x1 - x0   # window = same size as crop
 
+# Color palette for multi-class drawing
+CLASS_COLORS = [(0,255,0),(0,0,255),(255,165,0),(255,0,255),(0,255,255),
+                (128,255,0),(255,128,0),(0,128,255)]
+
 rce_head = st.session_state.get("rce_head")
 has_any_cnn = any(f"cnn_head_{n}" in st.session_state for n in BACKBONES)
+has_orb = "orb_refs" in st.session_state
 
-if rce_head is None and not has_any_cnn:
+if rce_head is None and not has_any_cnn and not has_orb:
     st.warning("No trained heads found. Go to **Model Tuning** and train at least one head.")
     st.stop()
 
@@ -77,8 +84,8 @@ def sliding_window_detect(
         feats = feature_fn(patch)
         label, conf = head.predict(feats)
 
-        # Fill heatmap with object confidence
-        if label == "object":
+        # Fill heatmap with non-background confidence
+        if label != "background":
             heatmap[y:y+win_h, x:x+win_w] = np.maximum(
                 heatmap[y:y+win_h, x:x+win_w], conf)
             if conf >= conf_thresh:
@@ -167,7 +174,7 @@ st.divider()
 # ===================================================================
 #  Side-by-side layout
 # ===================================================================
-col_rce, col_cnn = st.columns(2)
+col_rce, col_cnn, col_orb = st.columns(3)
 
 # -------------------------------------------------------------------
 #  LEFT — RCE Detection
@@ -194,10 +201,13 @@ with col_rce:
 
             # Final image with boxes
             final = right_img.copy()
+            class_labels = sorted(set(d[4] for d in dets)) if dets else []
             for x1d, y1d, x2d, y2d, lbl, cf in dets:
-                cv2.rectangle(final, (x1d, y1d), (x2d, y2d), (0, 255, 0), 2)
-                cv2.putText(final, f"{cf:.0%}", (x1d, y1d - 6),
-                            cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
+                ci = class_labels.index(lbl) if lbl in class_labels else 0
+                clr = CLASS_COLORS[ci % len(CLASS_COLORS)]
+                cv2.rectangle(final, (x1d, y1d), (x2d, y2d), clr, 2)
+                cv2.putText(final, f"{lbl} {cf:.0%}", (x1d, y1d - 6),
+                            cv2.FONT_HERSHEY_SIMPLEX, 0.4, clr, 1)
             rce_live.image(cv2.cvtColor(final, cv2.COLOR_BGR2RGB),
                            caption="RCE — Final Detections",
                            use_container_width=True)
@@ -263,10 +273,13 @@ with col_cnn:
 
             # Final image
             final = right_img.copy()
+            class_labels = sorted(set(d[4] for d in dets)) if dets else []
             for x1d, y1d, x2d, y2d, lbl, cf in dets:
-                cv2.rectangle(final, (x1d, y1d), (x2d, y2d), (0, 0, 255), 2)
-                cv2.putText(final, f"{cf:.0%}", (x1d, y1d - 6),
-                            cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2)
+                ci = class_labels.index(lbl) if lbl in class_labels else 0
+                clr = CLASS_COLORS[ci % len(CLASS_COLORS)]
+                cv2.rectangle(final, (x1d, y1d), (x2d, y2d), clr, 2)
+                cv2.putText(final, f"{lbl} {cf:.0%}", (x1d, y1d - 6),
+                            cv2.FONT_HERSHEY_SIMPLEX, 0.4, clr, 1)
             cnn_live.image(cv2.cvtColor(final, cv2.COLOR_BGR2RGB),
                            caption=f"{selected} — Final Detections",
                            use_container_width=True)
@@ -297,42 +310,146 @@ with col_cnn:
             st.session_state["cnn_det_ms"] = ms
 
 
+# -------------------------------------------------------------------
+#  RIGHT — ORB Detection
+# -------------------------------------------------------------------
+with col_orb:
+    st.header("🏛️ ORB Detection")
+    if not has_orb:
+        st.info("No ORB reference trained. Train one in **Model Tuning**.")
+    else:
+        orb_det   = st.session_state["orb_detector"]
+        orb_refs  = st.session_state["orb_refs"]
+        dt_thresh = st.session_state.get("orb_dist_thresh", 70)
+        min_m     = st.session_state.get("orb_min_matches", 5)
+        st.caption(f"References: {', '.join(orb_refs.keys())}  |  "
+                   f"dist<{dt_thresh}, min {min_m} matches")
+        orb_run = st.button("▶ Run ORB Scan", key="orb_run")
+
+        orb_progress = st.empty()
+        orb_live     = st.empty()
+        orb_results  = st.container()
+
+        if orb_run:
+            H, W = right_img.shape[:2]
+            positions = [(x, y)
+                         for y in range(0, H - win_h + 1, stride)
+                         for x in range(0, W - win_w + 1, stride)]
+            n_total = len(positions)
+            heatmap = np.zeros((H, W), dtype=np.float32)
+            detections = []
+            t0 = time.perf_counter()
+
+            clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+
+            for idx, (px, py) in enumerate(positions):
+                patch = right_img[py:py+win_h, px:px+win_w]
+                gray = cv2.cvtColor(patch, cv2.COLOR_BGR2GRAY)
+                gray = clahe.apply(gray)
+                kp, des = orb_det.orb.detectAndCompute(gray, None)
+
+                if des is not None:
+                    best_label, best_conf = "background", 0.0
+                    for lbl, ref in orb_refs.items():
+                        if ref["descriptors"] is None:
+                            continue
+                        matches = orb_det.bf.match(ref["descriptors"], des)
+                        good = [m for m in matches if m.distance < dt_thresh]
+                        conf = min(len(good) / max(min_m, 1), 1.0)
+                        if len(good) >= min_m and conf > best_conf:
+                            best_label, best_conf = lbl, conf
+
+                    if best_label != "background":
+                        heatmap[py:py+win_h, px:px+win_w] = np.maximum(
+                            heatmap[py:py+win_h, px:px+win_w], best_conf)
+                        if best_conf >= conf_thresh:
+                            detections.append(
+                                (px, py, px+win_w, py+win_h, best_label, best_conf))
+
+                if idx % 5 == 0 or idx == n_total - 1:
+                    orb_progress.progress((idx+1)/n_total,
+                                          text=f"Window {idx+1}/{n_total}")
+
+            total_ms = (time.perf_counter() - t0) * 1000
+            if detections:
+                detections = _nms(detections, nms_iou)
+
+            final = right_img.copy()
+            cls_labels = sorted(set(d[4] for d in detections)) if detections else []
+            for x1d, y1d, x2d, y2d, lbl, cf in detections:
+                ci = cls_labels.index(lbl) if lbl in cls_labels else 0
+                clr = CLASS_COLORS[ci % len(CLASS_COLORS)]
+                cv2.rectangle(final, (x1d, y1d), (x2d, y2d), clr, 2)
+                cv2.putText(final, f"{lbl} {cf:.0%}", (x1d, y1d - 6),
+                            cv2.FONT_HERSHEY_SIMPLEX, 0.4, clr, 1)
+            orb_live.image(cv2.cvtColor(final, cv2.COLOR_BGR2RGB),
+                           caption="ORB — Final Detections",
+                           use_container_width=True)
+            orb_progress.empty()
+
+            with orb_results:
+                om1, om2, om3, om4 = st.columns(4)
+                om1.metric("Detections", len(detections))
+                om2.metric("Windows", n_total)
+                om3.metric("Total Time", f"{total_ms:.0f} ms")
+                om4.metric("Per Window", f"{total_ms/max(n_total,1):.2f} ms")
+
+                if heatmap.max() > 0:
+                    hmap_color = cv2.applyColorMap(
+                        (heatmap / heatmap.max() * 255).astype(np.uint8),
+                        cv2.COLORMAP_JET)
+                    blend = cv2.addWeighted(right_img, 0.5, hmap_color, 0.5, 0)
+                    st.image(cv2.cvtColor(blend, cv2.COLOR_BGR2RGB),
+                             caption="ORB — Confidence Heatmap",
+                             use_container_width=True)
+
+                if detections:
+                    import pandas as pd
+                    df = pd.DataFrame(detections,
+                                      columns=["x1","y1","x2","y2","label","conf"])
+                    st.dataframe(df, use_container_width=True, hide_index=True)
+
+            st.session_state["orb_dets"] = detections
+            st.session_state["orb_det_ms"] = total_ms
+
+
 # ===================================================================
-#  Bottom — Comparison (if both have run)
+#  Bottom — Comparison (if any two have run)
 # ===================================================================
 rce_dets = st.session_state.get("rce_dets")
 cnn_dets = st.session_state.get("cnn_dets")
+orb_dets = st.session_state.get("orb_dets")
+
+methods = {}
+if rce_dets is not None:
+    methods["RCE"] = (rce_dets, st.session_state.get("rce_det_ms", 0), (0,255,0))
+if cnn_dets is not None:
+    methods["CNN"] = (cnn_dets, st.session_state.get("cnn_det_ms", 0), (0,0,255))
+if orb_dets is not None:
+    methods["ORB"] = (orb_dets, st.session_state.get("orb_det_ms", 0), (255,165,0))
 
-if rce_dets is not None and cnn_dets is not None:
+if len(methods) >= 2:
     st.divider()
     st.subheader("📊 Side-by-Side Comparison")
 
     import pandas as pd
-    comp = pd.DataFrame({
-        "Metric": ["Detections", "Best Confidence", "Total Time (ms)"],
-        "RCE": [
-            len(rce_dets),
-            f"{max((d[5] for d in rce_dets), default=0):.1%}",
-            f"{st.session_state.get('rce_det_ms', 0):.0f}",
-        ],
-        "CNN": [
-            len(cnn_dets),
-            f"{max((d[5] for d in cnn_dets), default=0):.1%}",
-            f"{st.session_state.get('cnn_det_ms', 0):.0f}",
-        ],
-    })
-    st.dataframe(comp, use_container_width=True, hide_index=True)
-
-    # Overlay both on one image
+    comp = {"Metric": ["Detections", "Best Confidence", "Total Time (ms)"]}
+    for name, (dets, ms, _) in methods.items():
+        comp[name] = [
+            len(dets),
+            f"{max((d[5] for d in dets), default=0):.1%}",
+            f"{ms:.0f}",
+        ]
+    st.dataframe(pd.DataFrame(comp), use_container_width=True, hide_index=True)
+
+    # Overlay all methods on one image
     overlay = right_img.copy()
-    for x1d, y1d, x2d, y2d, _, cf in rce_dets:
-        cv2.rectangle(overlay, (x1d, y1d), (x2d, y2d), (0, 255, 0), 2)
-        cv2.putText(overlay, f"RCE {cf:.0%}", (x1d, y1d - 6),
-                    cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 255, 0), 1)
-    for x1d, y1d, x2d, y2d, _, cf in cnn_dets:
-        cv2.rectangle(overlay, (x1d, y1d), (x2d, y2d), (0, 0, 255), 2)
-        cv2.putText(overlay, f"CNN {cf:.0%}", (x1d, y2d + 12),
-                    cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 1)
+    for name, (dets, _, clr) in methods.items():
+        for x1d, y1d, x2d, y2d, lbl, cf in dets:
+            cv2.rectangle(overlay, (x1d, y1d), (x2d, y2d), clr, 2)
+            cv2.putText(overlay, f"{name}:{lbl} {cf:.0%}", (x1d, y1d - 6),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.35, clr, 1)
+    legend = " | ".join(f"{n}={'green' if c==(0,255,0) else 'blue' if c==(0,0,255) else 'orange'}"
+                        for n, (_, _, c) in methods.items())
     st.image(cv2.cvtColor(overlay, cv2.COLOR_BGR2RGB),
-             caption="Green = RCE  |  Blue = CNN",
-             use_container_width=True)
+             caption=legend, use_container_width=True)

pages/7_Evaluation.py

@@ -0,0 +1,300 @@
+import streamlit as st
+import cv2
+import numpy as np
+import plotly.graph_objects as go
+import plotly.figure_factory as ff
+import sys, os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from src.detectors.rce.features import REGISTRY
+from src.models import BACKBONES
+
+st.set_page_config(page_title="Evaluation", layout="wide")
+st.title("📈 Evaluation: Confusion Matrix & PR Curves")
+
+# ---------------------------------------------------------------------------
+# Guard
+# ---------------------------------------------------------------------------
+if "pipeline_data" not in st.session_state:
+    st.error("Complete the **Data Lab** first.")
+    st.stop()
+
+assets   = st.session_state["pipeline_data"]
+crop     = assets["crop"]
+crop_aug = assets.get("crop_aug", crop)
+bbox     = assets.get("crop_bbox", (0, 0, crop.shape[1], crop.shape[0]))
+rois     = assets.get("rois", [{"label": "object", "bbox": bbox,
+                                 "crop": crop, "crop_aug": crop_aug}])
+
+rce_dets = st.session_state.get("rce_dets")
+cnn_dets = st.session_state.get("cnn_dets")
+orb_dets = st.session_state.get("orb_dets")
+
+if rce_dets is None and cnn_dets is None and orb_dets is None:
+    st.warning("Run detection on at least one method in **Real-Time Detection** first.")
+    st.stop()
+
+
+# ---------------------------------------------------------------------------
+# Ground truth from ROIs
+# ---------------------------------------------------------------------------
+gt_boxes = [(roi["bbox"], roi["label"]) for roi in rois]
+
+st.sidebar.subheader("Evaluation Settings")
+iou_thresh = st.sidebar.slider("IoU Threshold", 0.1, 0.9, 0.5, 0.05,
+                                help="Minimum IoU to count a detection as TP")
+
+st.subheader("Ground Truth (from Data Lab ROIs)")
+st.caption(f"{len(gt_boxes)} ground-truth ROIs defined")
+gt_vis = assets["right"].copy()
+for (bx0, by0, bx1, by1), lbl in gt_boxes:
+    cv2.rectangle(gt_vis, (bx0, by0), (bx1, by1), (0, 255, 255), 2)
+    cv2.putText(gt_vis, lbl, (bx0, by0 - 6),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 255), 1)
+st.image(cv2.cvtColor(gt_vis, cv2.COLOR_BGR2RGB),
+         caption="Ground Truth Annotations", use_container_width=True)
+
+st.divider()
+
+
+# ---------------------------------------------------------------------------
+# Matching helpers
+# ---------------------------------------------------------------------------
+def _iou(a, b):
+    xi1 = max(a[0], b[0]); yi1 = max(a[1], b[1])
+    xi2 = min(a[2], b[2]); yi2 = min(a[3], b[3])
+    inter = max(0, xi2 - xi1) * max(0, yi2 - yi1)
+    aa = (a[2] - a[0]) * (a[3] - a[1])
+    ab = (b[2] - b[0]) * (b[3] - b[1])
+    return inter / (aa + ab - inter + 1e-6)
+
+
+def match_detections(dets, gt_list, iou_thr):
+    """
+    Match detections to GT boxes.
+    Returns list of (det, matched_gt_label_or_None, iou) sorted by confidence.
+    """
+    dets_sorted = sorted(dets, key=lambda d: d[5], reverse=True)
+    matched_gt = set()
+    results = []
+
+    for det in dets_sorted:
+        det_box = det[:4]
+        det_label = det[4]
+        best_iou = 0.0
+        best_gt_idx = -1
+        best_gt_label = None
+
+        for gi, (gt_box, gt_label) in enumerate(gt_list):
+            if gi in matched_gt:
+                continue
+            iou_val = _iou(det_box, gt_box)
+            if iou_val > best_iou:
+                best_iou = iou_val
+                best_gt_idx = gi
+                best_gt_label = gt_label
+
+        if best_iou >= iou_thr and best_gt_idx >= 0:
+            matched_gt.add(best_gt_idx)
+            results.append((det, best_gt_label, best_iou))
+        else:
+            results.append((det, None, best_iou))
+
+    return results, len(gt_list) - len(matched_gt)
+
+
+def compute_pr_curve(dets, gt_list, iou_thr, steps=50):
+    """
+    Sweep confidence thresholds and compute precision/recall.
+    Returns (thresholds, precisions, recalls, f1s).
+    """
+    if not dets:
+        return [], [], [], []
+
+    thresholds = np.linspace(0.0, 1.0, steps)
+    precisions, recalls, f1s = [], [], []
+
+    for thr in thresholds:
+        filtered = [d for d in dets if d[5] >= thr]
+        if not filtered:
+            precisions.append(1.0)
+            recalls.append(0.0)
+            f1s.append(0.0)
+            continue
+
+        matched, n_missed = match_detections(filtered, gt_list, iou_thr)
+        tp = sum(1 for _, gt_lbl, _ in matched if gt_lbl is not None)
+        fp = sum(1 for _, gt_lbl, _ in matched if gt_lbl is None)
+        fn = n_missed
+
+        prec = tp / (tp + fp) if (tp + fp) > 0 else 1.0
+        rec = tp / (tp + fn) if (tp + fn) > 0 else 0.0
+        f1 = 2 * prec * rec / (prec + rec) if (prec + rec) > 0 else 0.0
+        precisions.append(prec)
+        recalls.append(rec)
+        f1s.append(f1)
+
+    return thresholds.tolist(), precisions, recalls, f1s
+
+
+def build_confusion_matrix(dets, gt_list, iou_thr):
+    """
+    Build a confusion matrix: rows = predicted, cols = actual.
+    Classes = all GT labels + 'background'.
+    """
+    gt_labels = sorted(set(lbl for _, lbl in gt_list))
+    all_labels = gt_labels + ["background"]
+
+    n = len(all_labels)
+    matrix = np.zeros((n, n), dtype=int)
+    label_to_idx = {lbl: i for i, lbl in enumerate(all_labels)}
+
+    matched, n_missed = match_detections(dets, gt_list, iou_thr)
+
+    for det, gt_lbl, _ in matched:
+        pred_lbl = det[4]
+        if gt_lbl is not None:
+            # TP or mislabel
+            pi = label_to_idx.get(pred_lbl, label_to_idx["background"])
+            gi = label_to_idx[gt_lbl]
+            matrix[pi][gi] += 1
+        else:
+            # FP
+            pi = label_to_idx.get(pred_lbl, label_to_idx["background"])
+            matrix[pi][label_to_idx["background"]] += 1
+
+    # FN: unmatched GT
+    matched_gt_indices = set()
+    for det, gt_lbl, _ in matched:
+        if gt_lbl is not None:
+            for gi, (_, gl) in enumerate(gt_list):
+                if gl == gt_lbl and gi not in matched_gt_indices:
+                    matched_gt_indices.add(gi)
+                    break
+    for gi, (_, gt_lbl) in enumerate(gt_list):
+        if gi not in matched_gt_indices:
+            matrix[label_to_idx["background"]][label_to_idx[gt_lbl]] += 1
+
+    return matrix, all_labels
+
+
+# ---------------------------------------------------------------------------
+# Collect all methods with detections
+# ---------------------------------------------------------------------------
+methods = {}
+if rce_dets is not None:
+    methods["RCE"] = rce_dets
+if cnn_dets is not None:
+    methods["CNN"] = cnn_dets
+if orb_dets is not None:
+    methods["ORB"] = orb_dets
+
+
+# ===================================================================
+# 1. Confusion Matrices
+# ===================================================================
+st.subheader("🔲 Confusion Matrices")
+cm_cols = st.columns(len(methods))
+
+for col, (name, dets) in zip(cm_cols, methods.items()):
+    with col:
+        st.markdown(f"**{name}**")
+        matrix, labels = build_confusion_matrix(dets, gt_boxes, iou_thresh)
+
+        fig_cm = ff.create_annotated_heatmap(
+            z=matrix.tolist(),
+            x=labels, y=labels,
+            colorscale="Blues",
+            showscale=True)
+        fig_cm.update_layout(
+            title=f"{name} Confusion Matrix",
+            xaxis_title="Actual",
+            yaxis_title="Predicted",
+            template="plotly_dark",
+            height=350)
+        fig_cm.update_yaxes(autorange="reversed")
+        st.plotly_chart(fig_cm, use_container_width=True)
+
+        # Summary metrics at this default threshold
+        matched, n_missed = match_detections(dets, gt_boxes, iou_thresh)
+        tp = sum(1 for _, g, _ in matched if g is not None)
+        fp = sum(1 for _, g, _ in matched if g is None)
+        fn = n_missed
+        prec = tp / (tp + fp) if (tp + fp) > 0 else 0.0
+        rec = tp / (tp + fn) if (tp + fn) > 0 else 0.0
+        f1 = 2 * prec * rec / (prec + rec) if (prec + rec) > 0 else 0.0
+
+        m1, m2, m3 = st.columns(3)
+        m1.metric("Precision", f"{prec:.1%}")
+        m2.metric("Recall", f"{rec:.1%}")
+        m3.metric("F1 Score", f"{f1:.1%}")
+
+
+# ===================================================================
+# 2. Precision-Recall Curves
+# ===================================================================
+st.divider()
+st.subheader("📉 Precision-Recall Curves")
+
+method_colors = {"RCE": "#00ff88", "CNN": "#4488ff", "ORB": "#ff8800"}
+fig_pr = go.Figure()
+fig_f1 = go.Figure()
+
+summary_rows = []
+
+for name, dets in methods.items():
+    thrs, precs, recs, f1s = compute_pr_curve(dets, gt_boxes, iou_thresh)
+    clr = method_colors.get(name, "#ffffff")
+
+    fig_pr.add_trace(go.Scatter(
+        x=recs, y=precs, mode="lines+markers",
+        name=name, line=dict(color=clr, width=2),
+        marker=dict(size=4)))
+
+    fig_f1.add_trace(go.Scatter(
+        x=thrs, y=f1s, mode="lines",
+        name=name, line=dict(color=clr, width=2)))
+
+    # AP (area under PR curve)
+    if recs and precs:
+        ap = float(np.trapz(precs, recs))
+    else:
+        ap = 0.0
+
+    best_f1_idx = int(np.argmax(f1s)) if f1s else 0
+    summary_rows.append({
+        "Method": name,
+        "AP": f"{abs(ap):.3f}",
+        "Best F1": f"{f1s[best_f1_idx]:.3f}" if f1s else "N/A",
+        "@ Threshold": f"{thrs[best_f1_idx]:.2f}" if thrs else "N/A",
+        "Detections": len(dets),
+    })
+
+fig_pr.update_layout(
+    title="Precision vs Recall",
+    xaxis_title="Recall", yaxis_title="Precision",
+    template="plotly_dark", height=400,
+    xaxis=dict(range=[0, 1.05]), yaxis=dict(range=[0, 1.05]))
+
+fig_f1.update_layout(
+    title="F1 Score vs Confidence Threshold",
+    xaxis_title="Confidence Threshold", yaxis_title="F1 Score",
+    template="plotly_dark", height=400,
+    xaxis=dict(range=[0, 1.05]), yaxis=dict(range=[0, 1.05]))
+
+pc1, pc2 = st.columns(2)
+pc1.plotly_chart(fig_pr, use_container_width=True)
+pc2.plotly_chart(fig_f1, use_container_width=True)
+
+
+# ===================================================================
+# 3. Summary Table
+# ===================================================================
+st.divider()
+st.subheader("📊 Summary")
+
+import pandas as pd
+st.dataframe(pd.DataFrame(summary_rows), use_container_width=True, hide_index=True)
+
+st.caption(f"All metrics computed at IoU threshold = **{iou_thresh:.2f}**. "
+           "Adjust in the sidebar to explore sensitivity.")

src/localization.py

@@ -0,0 +1,391 @@
+"""
+src/localization.py  —  Localization Strategy Library
+=====================================================
+Five strategies that decide WHERE to evaluate a recognition head.
+The head stays the same — only the search method changes.
+
+Strategies
+----------
+1. Exhaustive Sliding Window  — brute-force grid scan
+2. Image Pyramid              — multi-scale resize + sliding window
+3. Coarse-to-Fine Search      — two-pass hierarchical refinement
+4. Contour Proposals          — edge-driven candidate regions
+5. Template Matching          — OpenCV cross-correlation (no head)
+
+Every function returns the same tuple:
+    (detections, n_proposals, elapsed_ms, heatmap)
+"""
+
+import cv2
+import numpy as np
+import time
+
+
+# ===================================================================
+#  Shared utilities
+# ===================================================================
+
+def nms(dets, iou_thresh):
+    """Greedy NMS on list of (x1, y1, x2, y2, label, conf)."""
+    dets = sorted(dets, key=lambda d: d[5], reverse=True)
+    keep = []
+    while dets:
+        best = dets.pop(0)
+        keep.append(best)
+        dets = [d for d in dets if _iou(best, d) < iou_thresh]
+    return keep
+
+
+def _iou(a, b):
+    xi1, yi1 = max(a[0], b[0]), max(a[1], b[1])
+    xi2, yi2 = min(a[2], b[2]), min(a[3], b[3])
+    inter = max(0, xi2 - xi1) * max(0, yi2 - yi1)
+    aa = (a[2] - a[0]) * (a[3] - a[1])
+    ab = (b[2] - b[0]) * (b[3] - b[1])
+    return inter / (aa + ab - inter + 1e-6)
+
+
+# ===================================================================
+#  1. Exhaustive Sliding Window
+# ===================================================================
+
+def exhaustive_sliding_window(image, win_h, win_w, feature_fn, head,
+                               stride, conf_thresh, nms_iou):
+    """
+    Brute-force grid scan.  Evaluates the head at **every** position
+    spaced by *stride* pixels.
+    """
+    H, W = image.shape[:2]
+    heatmap = np.zeros((H, W), dtype=np.float32)
+    detections = []
+    n_proposals = 0
+    t0 = time.perf_counter()
+
+    for y in range(0, H - win_h + 1, stride):
+        for x in range(0, W - win_w + 1, stride):
+            patch = image[y:y + win_h, x:x + win_w]
+            feats = feature_fn(patch)
+            label, conf = head.predict(feats)
+            n_proposals += 1
+            if label == "object":
+                heatmap[y:y + win_h, x:x + win_w] = np.maximum(
+                    heatmap[y:y + win_h, x:x + win_w], conf)
+                if conf >= conf_thresh:
+                    detections.append((x, y, x + win_w, y + win_h, label, conf))
+
+    elapsed_ms = (time.perf_counter() - t0) * 1000
+    if detections:
+        detections = nms(detections, nms_iou)
+    return detections, n_proposals, elapsed_ms, heatmap
+
+
+# ===================================================================
+#  2. Image Pyramid
+# ===================================================================
+
+def image_pyramid(image, win_h, win_w, feature_fn, head,
+                  stride, conf_thresh, nms_iou,
+                  scales=(0.5, 0.75, 1.0, 1.25, 1.5)):
+    """
+    Resize the image at several scales, run a sliding window at each
+    level, and map detections back to original coordinates.
+    Finds objects at sizes different from the training crop.
+    """
+    H, W = image.shape[:2]
+    heatmap = np.zeros((H, W), dtype=np.float32)
+    detections = []
+    n_proposals = 0
+    t0 = time.perf_counter()
+
+    for scale in scales:
+        sH, sW = int(H * scale), int(W * scale)
+        if sH < win_h or sW < win_w:
+            continue
+        scaled = cv2.resize(image, (sW, sH))
+
+        for y in range(0, sH - win_h + 1, stride):
+            for x in range(0, sW - win_w + 1, stride):
+                patch = scaled[y:y + win_h, x:x + win_w]
+                feats = feature_fn(patch)
+                label, conf = head.predict(feats)
+                n_proposals += 1
+                if label == "object":
+                    # Map back to original image coordinates
+                    ox  = int(x / scale)
+                    oy  = int(y / scale)
+                    ox2 = min(int((x + win_w) / scale), W)
+                    oy2 = min(int((y + win_h) / scale), H)
+                    heatmap[oy:oy2, ox:ox2] = np.maximum(
+                        heatmap[oy:oy2, ox:ox2], conf)
+                    if conf >= conf_thresh:
+                        detections.append((ox, oy, ox2, oy2, label, conf))
+
+    elapsed_ms = (time.perf_counter() - t0) * 1000
+    if detections:
+        detections = nms(detections, nms_iou)
+    return detections, n_proposals, elapsed_ms, heatmap
+
+
+# ===================================================================
+#  3. Coarse-to-Fine Search
+# ===================================================================
+
+def coarse_to_fine(image, win_h, win_w, feature_fn, head,
+                   fine_stride, conf_thresh, nms_iou,
+                   coarse_factor=4, refine_radius=2):
+    """
+    Two-pass hierarchical search.
+
+    Pass 1 — Scan at *coarse_factor × fine_stride* to cheaply identify
+             hot regions (using a relaxed threshold of 0.7 × conf_thresh).
+    Pass 2 — Re-scan **only** the neighbourhood of each hit at
+             *fine_stride*, within *refine_radius* steps in each direction.
+    """
+    H, W = image.shape[:2]
+    heatmap = np.zeros((H, W), dtype=np.float32)
+    detections = []
+    n_proposals = 0
+    t0 = time.perf_counter()
+
+    coarse_stride = fine_stride * coarse_factor
+
+    # --- Pass 1: coarse ---
+    hot_spots = []
+    for y in range(0, H - win_h + 1, coarse_stride):
+        for x in range(0, W - win_w + 1, coarse_stride):
+            patch = image[y:y + win_h, x:x + win_w]
+            feats = feature_fn(patch)
+            label, conf = head.predict(feats)
+            n_proposals += 1
+            if label == "object" and conf >= conf_thresh * 0.7:
+                hot_spots.append((x, y))
+                heatmap[y:y + win_h, x:x + win_w] = np.maximum(
+                    heatmap[y:y + win_h, x:x + win_w], conf)
+
+    # --- Pass 2: fine around hot spots ---
+    visited = set()
+    for hx, hy in hot_spots:
+        for dy in range(-refine_radius, refine_radius + 1):
+            for dx in range(-refine_radius, refine_radius + 1):
+                x = hx + dx * fine_stride
+                y = hy + dy * fine_stride
+                if (x, y) in visited:
+                    continue
+                if x < 0 or y < 0 or x + win_w > W or y + win_h > H:
+                    continue
+                visited.add((x, y))
+                patch = image[y:y + win_h, x:x + win_w]
+                feats = feature_fn(patch)
+                label, conf = head.predict(feats)
+                n_proposals += 1
+                if label == "object":
+                    heatmap[y:y + win_h, x:x + win_w] = np.maximum(
+                        heatmap[y:y + win_h, x:x + win_w], conf)
+                    if conf >= conf_thresh:
+                        detections.append((x, y, x + win_w, y + win_h,
+                                           label, conf))
+
+    elapsed_ms = (time.perf_counter() - t0) * 1000
+    if detections:
+        detections = nms(detections, nms_iou)
+    return detections, n_proposals, elapsed_ms, heatmap
+
+
+# ===================================================================
+#  4. Contour Proposals
+# ===================================================================
+
+def contour_proposals(image, win_h, win_w, feature_fn, head,
+                      conf_thresh, nms_iou,
+                      canny_low=50, canny_high=150,
+                      area_tolerance=3.0):
+    """
+    Generate candidate regions from image structure:
+    Canny edges → morphological closing → contour extraction.
+    Keep contours whose bounding-box area is within *area_tolerance*×
+    of the window area, centre a window on each, and score with the head.
+
+    Returns an extra key ``edge_map`` in the heatmap slot for
+    visualisation on the page (the caller can detect this).
+    """
+    H, W = image.shape[:2]
+    heatmap = np.zeros((H, W), dtype=np.float32)
+    detections = []
+    n_proposals = 0
+    t0 = time.perf_counter()
+
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    blurred = cv2.GaussianBlur(gray, (5, 5), 0)
+    edges = cv2.Canny(blurred, canny_low, canny_high)
+    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))
+    edges = cv2.morphologyEx(edges, cv2.MORPH_CLOSE, kernel)
+
+    contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL,
+                                   cv2.CHAIN_APPROX_SIMPLE)
+
+    target_area = win_h * win_w
+    min_area = target_area / area_tolerance
+    max_area = target_area * area_tolerance
+
+    for cnt in contours:
+        area = cv2.contourArea(cnt)
+        if area < min_area or area > max_area:
+            continue
+        bx, by, bw, bh = cv2.boundingRect(cnt)
+        # Centre a window on the contour centre
+        cx, cy = bx + bw // 2, by + bh // 2
+        px = max(0, min(cx - win_w // 2, W - win_w))
+        py = max(0, min(cy - win_h // 2, H - win_h))
+
+        patch = image[py:py + win_h, px:px + win_w]
+        if patch.shape[0] != win_h or patch.shape[1] != win_w:
+            continue
+
+        feats = feature_fn(patch)
+        label, conf = head.predict(feats)
+        n_proposals += 1
+
+        if label == "object":
+            heatmap[py:py + win_h, px:px + win_w] = np.maximum(
+                heatmap[py:py + win_h, px:px + win_w], conf)
+            if conf >= conf_thresh:
+                detections.append((px, py, px + win_w, py + win_h,
+                                   label, conf))
+
+    elapsed_ms = (time.perf_counter() - t0) * 1000
+    if detections:
+        detections = nms(detections, nms_iou)
+    return detections, n_proposals, elapsed_ms, heatmap, edges
+
+
+# ===================================================================
+#  5. Template Matching
+# ===================================================================
+
+def template_matching(image, template, conf_thresh, nms_iou,
+                      method=cv2.TM_CCOEFF_NORMED):
+    """
+    OpenCV normalised cross-correlation.
+    No trained head — pure pixel similarity between *template* and every
+    image position.  Extremely fast (optimised C++) but not invariant to
+    rotation, scale, or illumination.
+    """
+    H, W = image.shape[:2]
+    th, tw = template.shape[:2]
+    t0 = time.perf_counter()
+
+    result = cv2.matchTemplate(image, template, method)
+
+    if method in (cv2.TM_CCOEFF_NORMED, cv2.TM_CCORR_NORMED):
+        score_map = np.clip(result, 0, 1).astype(np.float32)
+    else:
+        lo, hi = result.min(), result.max()
+        score_map = ((result - lo) / (hi - lo + 1e-6)).astype(np.float32)
+
+    # Full-size heatmap (resize for visualisation)
+    heatmap = cv2.resize(score_map, (W, H), interpolation=cv2.INTER_LINEAR)
+
+    # Extract detections above threshold
+    detections = []
+    locs = np.where(score_map >= conf_thresh)
+    for y, x in zip(*locs):
+        detections.append((int(x), int(y), int(x + tw), int(y + th),
+                           "object", float(score_map[y, x])))
+
+    n_proposals = score_map.shape[0] * score_map.shape[1]
+    elapsed_ms = (time.perf_counter() - t0) * 1000
+
+    if detections:
+        detections = nms(detections, nms_iou)
+    return detections, n_proposals, elapsed_ms, heatmap
+
+
+# ===================================================================
+#  Registry  —  metadata used by the Streamlit page
+# ===================================================================
+
+STRATEGIES = {
+    "Exhaustive Sliding Window": {
+        "icon": "🔲",
+        "fn":   exhaustive_sliding_window,
+        "needs_head": True,
+        "short": "Brute-force grid scan at every stride position.",
+        "detail": (
+            "The simplest approach: a fixed-size window slides across the "
+            "**entire image** at regular intervals.  At every position the "
+            "patch is extracted, features are computed, and the head classifies it.\n\n"
+            "**Complexity:** $O\\!\\left(\\frac{W}{s} \\times \\frac{H}{s}\\right)$ "
+            "where $s$ = stride.\n\n"
+            "**Pro:** Guaranteed to evaluate every location — nothing is missed.\n\n"
+            "**Con:** Extremely slow on large images or small strides."
+        ),
+    },
+    "Image Pyramid": {
+        "icon": "🔺",
+        "fn":   image_pyramid,
+        "needs_head": True,
+        "short": "Multi-scale resize + sliding window.",
+        "detail": (
+            "Builds a **Gaussian pyramid** by resizing the image to several "
+            "scales (e.g. 50 %, 75 %, 100 %, 125 %, 150 %).  A sliding-window "
+            "scan runs at each level and detections are mapped back to original "
+            "coordinates.\n\n"
+            "**Why:** The training crop has a fixed size.  If the real object "
+            "appears larger or smaller in the scene, a single-scale scan will "
+            "miss it.  The pyramid handles **scale variation**.\n\n"
+            "**Cost:** Multiplies the number of proposals by the number of "
+            "scales — slower than single-scale exhaustive."
+        ),
+    },
+    "Coarse-to-Fine": {
+        "icon": "🎯",
+        "fn":   coarse_to_fine,
+        "needs_head": True,
+        "short": "Two-pass hierarchical refinement.",
+        "detail": (
+            "**Pass 1 — Coarse:** Scans the image with a large stride "
+            "(coarse\\_factor × fine\\_stride) using a relaxed confidence "
+            "threshold (70 % of the target) to cheaply identify *hot regions*.\n\n"
+            "**Pass 2 — Fine:** Re-scans **only** the neighbourhood around "
+            "each coarse hit at the fine stride, within *refine\\_radius* steps "
+            "in each direction.\n\n"
+            "**Speedup:** Typically **3–10×** faster than exhaustive when the "
+            "object is spatially sparse (i.e. most of the image is background)."
+        ),
+    },
+    "Contour Proposals": {
+        "icon": "✏️",
+        "fn":   contour_proposals,
+        "needs_head": True,
+        "short": "Edge-driven candidate regions scored by head.",
+        "detail": (
+            "Instead of scanning everywhere, this method lets **image "
+            "structure** drive the search:\n\n"
+            "1. Canny edge detection\n"
+            "2. Morphological closing to bridge nearby edges\n"
+            "3. External contour extraction\n"
+            "4. Filter contours whose area falls within *area\\_tolerance* "
+            "of the window area\n"
+            "5. Centre a window on each surviving contour and score with "
+            "the trained head\n\n"
+            "**Proposals evaluated:** Typically 10–100× fewer than exhaustive. "
+            "Speed depends on scene complexity (more edges → more proposals)."
+        ),
+    },
+    "Template Matching": {
+        "icon": "📋",
+        "fn":   template_matching,
+        "needs_head": False,
+        "short": "OpenCV cross-correlation — no head needed.",
+        "detail": (
+            "Classical **normalised cross-correlation** (NCC).  Slides the "
+            "crop template over the image computing pixel-level similarity "
+            "at every position.  No trained head is involved.\n\n"
+            "**Speed:** Runs entirely in OpenCV's optimised C++ backend — "
+            "orders of magnitude faster than Python-level loops.\n\n"
+            "**Limitation:** Not invariant to rotation, scale, or illumination "
+            "changes.  Works best when the object appears at the **exact same "
+            "size and orientation** as the crop."
+        ),
+    },
+}