refactor: tab-based routing with two pipelines (Stereo+Depth & Generalisation)

- Rewrite app.py as sidebar routing controller (no more multi-page Streamlit)
- Add tabs/stereo/ (7 stages: data_lab, feature_lab, model_tuning, localization,
detection, evaluation, stereo_depth)
- Add tabs/generalisation/ (6 stages: same minus stereo_depth)
- Add utils/middlebury_loader.py (PFM + calib parsing, scene group scanner)
- Namespace session state into stereo_pipeline / gen_pipeline dicts
- Fix data leakage: train on LEFT/variant-A, detect on RIGHT/variant-B
- All widget keys prefixed per pipeline to prevent collisions
- Remove deprecated pages/ directory

CLAUDE_CODE_PROMPT.md

@@ -0,0 +1,656 @@
+# Claude Code Implementation Prompt
+# Recognition-BenchMark — Full Restructure
+
+---
+
+## Context
+
+This is a Streamlit-based stereo-vision benchmarking platform called **Recognition-BenchMark**. It compares a custom hand-crafted feature extractor called **RCE (Relative Contextual Encoding)** against CNN-based deep learning approaches for object recognition and depth estimation.
+
+### Current Project Structure
+
+```
+app.py                          ← Landing page (home)
+pages/
+├── 2_Data_Lab.py               ← Stage 1
+├── 3_Feature_Lab.py            ← Stage 2
+├── 4_Model_Tuning.py           ← Stage 3
+├── 5_Localization_Lab.py       ← Stage 4
+├── 6_RealTime_Detection.py     ← Stage 5
+├── 7_Evaluation.py             ← Stage 6
+└── 8_Stereo_Geometry.py        ← Stage 7
+src/
+├── config.py                   ← App configuration constants
+├── detectors/
+│   ├── base.py                 ← Base detector class
+│   ├── rce/
+│   │   ├── __init__.py
+│   │   └── features.py         ← RCE feature extractor (DO NOT MODIFY)
+│   ├── mobilenet.py            ← MobileNetV3 detector (DO NOT MODIFY)
+│   ├── mobilevit.py            ← MobileViT detector (DO NOT MODIFY)
+│   ├── resnet.py               ← ResNet-18 detector (DO NOT MODIFY)
+│   ├── orb.py                  ← ORB detector (DO NOT MODIFY)
+│   └── yolo.py                 ← YOLOv8 detector (DO NOT MODIFY)
+├── localization.py             ← Localization strategies (DO NOT MODIFY)
+└── models.py                   ← Model loading utilities (DO NOT MODIFY)
+models/
+├── mobilenet_v3_head.pkl
+├── mobilenet_v3.pth
+├── mobilevit_head.pkl
+├── mobilevit_xxs.pth
+├── orb_reference.pkl
+├── resnet18_head.pkl
+├── resnet18.pth
+└── yolov8n.pt
+data/
+└── middlebury/                 ← Bundled dataset (already present)
+```
+
+**The entire `src/` directory must not be modified.** All detector logic, feature extraction, localization strategies, and model loading are already implemented there. The pages in `pages/` import from `src/` and must be migrated to the new `tabs/` structure while continuing to import from `src/`.
+
+---
+
+## Critical Bug To Fix
+
+**Data leakage through circular evaluation.** Currently the detection/recognition stage runs on the same left image used to define the training ROI. This is scientifically invalid — the model is tested on its own training source.
+
+**The fix:**
+- In the Stereo pipeline: train on LEFT image crop → detect on RIGHT image
+- In the Generalisation pipeline: train on image 1 crop → detect on image 2
+
+This must be propagated through session state so every stage after Data Lab knows which image is for training (source) and which is for testing (target).
+
+---
+
+## Target Architecture
+
+### File Structure After Refactor
+
+```
+app.py                              ← REPLACE: routing controller + home page
+tabs/
+├── stereo/
+│   ├── __init__.py
+│   ├── data_lab.py                 ← NEW: replaces pages/2_Data_Lab.py for stereo
+│   ├── feature_lab.py              ← MIGRATE: from pages/3_Feature_Lab.py
+│   ├── model_tuning.py             ← MIGRATE: from pages/4_Model_Tuning.py
+│   ├── localization.py             ← MIGRATE: from pages/5_Localization_Lab.py
+│   ├── detection.py                ← MIGRATE + FIX: from pages/6_RealTime_Detection.py
+│   ├── evaluation.py               ← MIGRATE: from pages/7_Evaluation.py
+│   └── stereo_depth.py             ← MIGRATE: from pages/8_Stereo_Geometry.py
+├── generalisation/
+│   ├── __init__.py
+│   ├── data_lab.py                 ← NEW: generalisation-specific data loading
+│   ├── feature_lab.py              ← ADAPT: stereo version with gen_pipeline keys
+│   ├── model_tuning.py             ← ADAPT: stereo version with gen_pipeline keys
+│   ├── localization.py             ← ADAPT: stereo version with gen_pipeline keys
+│   ├── detection.py                ← ADAPT + FIX: stereo version with gen_pipeline keys
+│   └── evaluation.py               ← ADAPT: stereo version with gen_pipeline keys
+utils/
+└── middlebury_loader.py            ← NEW: dataset scanning, loading, parsing
+src/                                ← DO NOT TOUCH: all detector/model logic stays here
+pages/                              ← DELETE after migration is complete and verified
+data/
+└── middlebury/                     ← Already present, do not modify
+```
+
+---
+
+## Part 1 — app.py Routing Controller
+
+Replace the existing `app.py` entirely. The new `app.py` is a **routing controller** that:
+
+1. Sets page config (keep existing title/icon/layout)
+2. Builds the sidebar navigation manually using session state
+3. Renders the correct module based on navigation state
+4. Preserves the existing landing page content (pipeline overview, models, depth info)
+
+### Sidebar Logic
+
+```python
+import streamlit as st
+
+# Top-level navigation
+st.sidebar.title("🦅 Recognition BenchMark")
+
+top_section = st.sidebar.radio(
+    "Navigation",
+    ["🏠 Home", "📷 Stereo + Depth", "🌍 Generalisation"],
+    key="top_nav"
+)
+
+if top_section == "🏠 Home":
+    # render home/landing page content inline in app.py
+    render_home()
+
+elif top_section == "📷 Stereo + Depth":
+    stereo_stage = st.sidebar.radio(
+        "Pipeline Stage",
+        [
+            "🧪 1 · Data Lab",
+            "🔬 2 · Feature Lab",
+            "⚙️ 3 · Model Tuning",
+            "🔍 4 · Localization",
+            "🎯 5 · Detection",
+            "📈 6 · Evaluation",
+            "📐 7 · Stereo Depth"
+        ],
+        key="stereo_stage"
+    )
+    # import and call the appropriate render() function from tabs/stereo/
+
+elif top_section == "🌍 Generalisation":
+    gen_stage = st.sidebar.radio(
+        "Pipeline Stage",
+        [
+            "🧪 1 · Data Lab",
+            "🔬 2 · Feature Lab",
+            "⚙️ 3 · Model Tuning",
+            "🔍 4 · Localization",
+            "🎯 5 · Detection",
+            "📈 6 · Evaluation"
+        ],
+        key="gen_stage"
+    )
+    # import and call the appropriate render() function from tabs/generalisation/
+```
+
+### Stage Guard Pattern
+
+Every stage except Data Lab must check if the previous stage is complete. Use this pattern at the top of each stage's `render()` function:
+
+```python
+def render():
+    pipe = st.session_state.get("stereo_pipeline", {})
+    if "train_image" not in pipe:
+        st.warning("⚠️ Complete **Data Lab** first before accessing this stage.")
+        st.stop()
+    # ... rest of stage logic
+```
+
+### Session State Namespacing
+
+**Critical:** The two pipelines must never share session state keys.
+
+- Stereo pipeline uses: `st.session_state["stereo_pipeline"]` — a dict containing all stereo stage data
+- Generalisation pipeline uses: `st.session_state["gen_pipeline"]` — a dict containing all generalisation stage data
+
+Within each dict, use consistent keys:
+```python
+# Stereo pipeline dict keys
+stereo_pipeline = {
+    "train_image":    np.ndarray,   # LEFT image — used for ROI + training
+    "test_image":     np.ndarray,   # RIGHT image — used for detection
+    "calib":          dict,         # parsed calibration parameters
+    "disparity_gt":   np.ndarray,   # ground truth disparity (optional, may be None)
+    "roi":            dict,         # {"x", "y", "w", "h", "label"}
+    "crop":           np.ndarray,   # cropped ROI from train_image
+    "crop_aug":       list,         # augmented crop variants
+    "active_modules": list,         # RCE modules ["intensity", "sobel", "spectral"]
+    "rce_head":       object,       # trained LogisticRegression
+    "cnn_heads":      dict,         # {"ResNet-18": ..., "MobileNetV3": ..., "MobileViT-XXS": ...}
+    "rce_dets":       list,         # detection results on test_image
+    "cnn_dets":       dict,         # detection results per CNN model
+    "source":         str,          # "middlebury" or "custom"
+    "scene_name":     str,          # Middlebury scene name (if source == "middlebury")
+}
+
+# Generalisation pipeline dict keys — same structure minus calib/disparity_gt
+gen_pipeline = {
+    "train_image":    np.ndarray,   # im0.png from training scene variant
+    "test_image":     np.ndarray,   # im0.png from test scene variant
+    "roi":            dict,
+    "crop":           np.ndarray,
+    "crop_aug":       list,
+    "active_modules": list,
+    "rce_head":       object,
+    "cnn_heads":      dict,
+    "rce_dets":       list,
+    "cnn_dets":       dict,
+    "source":         str,          # "middlebury" or "custom"
+    "scene_group":    str,          # e.g. "artroom" (Middlebury only)
+    "train_scene":    str,          # e.g. "artroom1" (Middlebury only)
+    "test_scene":     str,          # e.g. "artroom2" (Middlebury only)
+}
+```
+
+---
+
+## Part 2 — Middlebury Loader Utility
+
+Create `utils/middlebury_loader.py` with the following functions:
+
+### `scan_dataset_root(root_path: str) -> list[str]`
+- Scan root directory for valid scene folders
+- A valid scene must contain: `im0.png`, `im1.png`, `calib.txt`
+- Return sorted list of scene names
+
+### `get_scene_groups(root_path: str) -> dict`
+- Scan all valid scenes and group them by scene base name (strip trailing digit)
+- e.g. `artroom1`, `artroom2` → group `"artroom"`
+- Return dict: `{"artroom": ["artroom1", "artroom2"], "curule": ["curule1", "curule2", "curule3"], ...}`
+- Used by Tab 2 to present scene group selection then variant selection
+
+### `get_available_views(scene_path: str) -> list[dict]`
+- This dataset has NO multi-exposure variants (no im0E.png etc.)
+- Function kept for future compatibility but always returns single entry:
+  `[{"suffix": "", "label": "Primary (im0/im1)"}]`
+
+### `load_stereo_pair(scene_path: str, view_suffix: str = '') -> dict`
+- Load `im0{suffix}.png` as left image (train_image)
+- Load `im1{suffix}.png` as right image (test_image)
+- Load and parse `calib.txt`
+- Load `disp0.pfm` if it exists (else None)
+- Return dict with keys: `left`, `right`, `calib`, `disparity_gt`
+
+### `load_single_view(scene_path: str, view_suffix: str) -> np.ndarray`
+- Load and return a single image: `im0{suffix}.png`
+- Used by generalisation tab when selecting individual views
+
+### `parse_calib(calib_path: str) -> dict`
+Parse Middlebury `calib.txt` format:
+```
+cam0=[fx 0 cx; 0 fy cy; 0 0 1]
+cam1=[fx 0 cx; 0 fy cy; 0 0 1]
+doffs=x_offset
+baseline=Bmm
+width=W
+height=H
+ndisp=N
+vmin=v
+vmax=v
+```
+Extract and return: `{"fx": float, "baseline": float, "doffs": float, "width": int, "height": int, "ndisp": int}`
+
+Use regex to extract `fx` from the camera matrix string: first numeric value after `cam0=[`.
+
+### `load_pfm(filepath: str) -> np.ndarray`
+Load PFM (Portable FloatMap) file:
+- Read header line (`PF` = color, `Pf` = grayscale)
+- Read dimensions line
+- Read scale factor (negative = little-endian)
+- Read float32 binary data
+- Flip vertically (PFM origin is bottom-left)
+- Return numpy array
+
+### Dataset Root Resolution
+
+The dataset is **bundled directly in the repo** at `./data/middlebury/`. No user configuration needed.
+
+```python
+DEFAULT_MIDDLEBURY_ROOT = "./data/middlebury"
+```
+
+If the path does not exist or contains no valid scenes, show a clear error. This should not happen in normal deployment since the data is bundled.
+
+### Bundled Scenes Reference
+
+The following 10 scene folders are bundled, forming 4 scene groups:
+
+```python
+BUNDLED_SCENES = {
+    "artroom":   ["artroom1",  "artroom2"],
+    "curule":    ["curule1",   "curule2",   "curule3"],
+    "skates":    ["skates1",   "skates2"],
+    "skiboots":  ["skiboots1", "skiboots2", "skiboots3"],
+}
+```
+
+Each folder contains exactly: `im0.png`, `im1.png`, `disp0.pfm`, `disp1.pfm`, `calib.txt`.
+
+There are **no multi-exposure variants** (no `im0E.png` etc.) — the scene groups ARE the multi-condition variants. `artroom1` and `artroom2` are different captures of the same artroom scene.
+
+---
+
+## Part 3 — Tab 1: Stereo Data Lab
+
+Create `tabs/stereo/data_lab.py` with a `render()` function.
+
+### Data Source Selection
+
+```python
+st.header("🧪 Data Lab — Stereo + Depth")
+st.info("**How this works:** Define your object of interest in the LEFT image. The system trains on it and attempts to recognise it in the RIGHT image — a genuinely different viewpoint.")
+
+source = st.radio(
+    "Data source",
+    ["📦 Middlebury Dataset", "📁 Upload your own files"],
+    horizontal=True
+)
+```
+
+### If Middlebury Selected
+
+```
+1. Scan dataset root → show selectbox of available scenes
+2. Auto-load im0.png (train/left) and im1.png (test/right)
+3. Auto-load calib.txt → parse parameters
+4. Auto-load disp0.pfm if present
+5. Display LEFT image (train) and RIGHT image (test) side by side
+6. Show parsed calibration parameters in an expander
+7. Show ground truth disparity colormap if available
+```
+
+Show a clear visual label:
+- Left image labeled: `🟦 TRAIN IMAGE (Left)` 
+- Right image labeled: `🟥 TEST IMAGE (Right)`
+
+### If Custom Upload Selected
+
+```
+- Left image uploader (png/jpg) → labeled as TRAIN IMAGE
+- Right image uploader (png/jpg) → labeled as TEST IMAGE  
+- Calibration file uploader (txt) — REQUIRED for depth estimation
+- PFM ground truth uploader (pfm) — optional, disables depth evaluation if missing
+- If calibration file not provided: show warning "Depth estimation will be disabled"
+```
+
+### ROI Definition
+
+After images are loaded (either source):
+
+```
+1. Display LEFT (train) image only for ROI definition
+2. Use streamlit-cropper or manual coordinate inputs for ROI selection
+   - If streamlit-cropper available: use it
+   - Fallback: four number_input widgets for x, y, w, h
+3. Text input for class label (default: "object")
+4. Show cropped ROI preview
+5. "Lock Data Lab" button → saves everything to st.session_state["stereo_pipeline"]
+```
+
+### Data Augmentation
+
+After ROI is locked, show augmentation controls (preserve existing augmentation logic):
+- Rotation, brightness, contrast, noise, blur, flip
+- Preview augmented crops
+- "Apply Augmentation" button
+
+### What Gets Saved to Session State
+
+```python
+st.session_state["stereo_pipeline"] = {
+    "train_image": left_image,      # numpy array, BGR
+    "test_image":  right_image,     # numpy array, BGR  ← KEY FIX
+    "calib":       calib_dict,      # parsed params or None
+    "disparity_gt": disp_gt,        # numpy array or None
+    "roi":         {"x":x, "y":y, "w":w, "h":h, "label":label},
+    "crop":        cropped_roi,
+    "crop_aug":    augmented_list,
+    "source":      "middlebury" or "custom",
+    "scene_name":  scene_name or "",
+}
+```
+
+---
+
+## Part 4 — Tab 2: Generalisation Data Lab
+
+Create `tabs/generalisation/data_lab.py` with a `render()` function.
+
+### Key Difference From Stereo Data Lab
+
+- No calibration file
+- No depth estimation
+- Two images can be completely independent OR different views from Middlebury
+- Goal is testing appearance generalisation, not stereo geometry
+
+### Data Source Selection
+
+```python
+st.header("🧪 Data Lab — Generalisation")
+st.info("**How this works:** Train on one image, test on a completely different image of the same object. No stereo geometry — pure recognition generalisation.")
+
+source = st.radio(
+    "Data source",
+    ["📦 Middlebury Multi-View", "📁 Upload your own files"],
+    horizontal=True
+)
+```
+
+### If Middlebury Selected
+
+```
+1. Show scene group selector: ["artroom", "curule", "skates", "skiboots"]
+2. Based on selected group, show available variants:
+   - artroom → [artroom1, artroom2]
+   - curule  → [curule1, curule2, curule3]
+   - skates  → [skates1, skates2]
+   - skiboots → [skiboots1, skiboots2, skiboots3]
+3. Two selectboxes:
+   - "Training scene" → user picks one variant (e.g. artroom1)
+   - "Test scene"     → user picks a DIFFERENT variant (e.g. artroom2)
+   - Validate: training scene ≠ test scene, show error if same selected
+4. Load train_scene/im0.png as train_image
+5. Load test_scene/im0.png as test_image
+   (NOTE: both are LEFT images im0.png, from different scene variants)
+6. Display both side by side with clear labels
+```
+
+Show labels:
+- Train image: `🟦 TRAIN IMAGE (artroom1)`
+- Test image: `🟥 TEST IMAGE (artroom2)`
+
+Also show an explanation: *"Both images show the same scene type captured under different conditions. The model trains on one variant and must recognise the same object class in the other — testing genuine appearance generalisation."*
+
+### If Custom Upload Selected
+
+```
+- Train image uploader → labeled TRAIN IMAGE
+- Test image uploader → labeled TEST IMAGE
+- No calibration, no PFM needed
+- Simple, low barrier
+```
+
+### ROI Definition and Augmentation
+
+Same as stereo data lab but on the TRAIN image only. Save to `st.session_state["gen_pipeline"]` with same key structure (minus calib and disparity_gt).
+
+---
+
+## Part 5 — Migrate Existing Pipeline Stages
+
+The existing pages (Feature Lab, Model Tuning, Localization, Detection, Evaluation, Stereo Depth) must be migrated into the new `tabs/` structure.
+
+### Migration Rules
+
+1. **Read each existing page file** before migrating it:
+   - `pages/2_Data_Lab.py` → split into `tabs/stereo/data_lab.py` and `tabs/generalisation/data_lab.py`
+   - `pages/3_Feature_Lab.py` → `tabs/stereo/feature_lab.py` (adapt for `tabs/generalisation/feature_lab.py`)
+   - `pages/4_Model_Tuning.py` → `tabs/stereo/model_tuning.py`
+   - `pages/5_Localization_Lab.py` → `tabs/stereo/localization.py`
+   - `pages/6_RealTime_Detection.py` → `tabs/stereo/detection.py` ← apply data leakage fix here
+   - `pages/7_Evaluation.py` → `tabs/stereo/evaluation.py`
+   - `pages/8_Stereo_Geometry.py` → `tabs/stereo/stereo_depth.py`
+
+2. **Each page becomes a module** with a `render()` function — wrap all existing page code inside `def render(): ...`
+
+3. **Update all session state reads** — the existing pages use `st.session_state.get("pipeline_data", {})` or similar flat keys. Replace with namespaced dicts:
+   - Stereo stages: `st.session_state.get("stereo_pipeline", {})`
+   - Generalisation stages: `st.session_state.get("gen_pipeline", {})`
+
+4. **Preserve all imports from `src/`** — every `from src.xxx import yyy` in the existing pages must be kept exactly as-is
+
+5. **Detection stage fix** — the critical data leakage fix:
+   - OLD: detection runs on the same image used for training ROI definition
+   - NEW: `image_to_scan = pipe["test_image"]` ← the other image
+
+### Stage Guard Template
+
+```python
+def render():
+    pipe = st.session_state.get("stereo_pipeline", {})  # or gen_pipeline
+    
+    required_keys = ["train_image", "test_image", "crop_aug"]
+    missing = [k for k in required_keys if k not in pipe]
+    if missing:
+        st.warning("⚠️ Complete the **Data Lab** stage first.")
+        st.info("Go to: 📷 Stereo + Depth → 🧪 Data Lab")
+        st.stop()
+```
+
+### Specific Migration Notes Per Stage
+
+**Feature Lab (Stage 2):**
+- Visualise features extracted from `pipe["crop"]` (from train_image)
+- No changes needed beyond session state key updates
+
+**Model Tuning (Stage 3):**
+- Training data comes from `pipe["crop_aug"]` (augmented crops of train_image ROI)
+- Negatives sampled from `pipe["train_image"]` (not test_image)
+- No changes needed beyond session state key updates
+
+**Detection (Stage 5) — CRITICAL FIX:**
+- Run sliding window on `pipe["test_image"]` NOT `pipe["train_image"]`
+- Add a visual reminder in the UI: *"Running detection on TEST image (right/second image)"*
+- For stereo: show test_image (right) with detection results
+- For generalisation: show test_image (different exposure) with detection results
+
+**Stereo Depth (Stage 7 — stereo only):**
+- Requires `pipe["calib"]` to be not None
+- If calib is None (custom upload without calibration): show warning and disable depth computation
+- If disparity_gt is None: skip ground truth comparison, show note
+- Otherwise: preserve existing StereoSGBM logic entirely
+
+---
+
+## Part 6 — Session Status Widget Update
+
+Update the session status display in `app.py` (home page) to show status for BOTH pipelines:
+
+```python
+st.header("📋 Session Status")
+
+col1, col2 = st.columns(2)
+
+with col1:
+    st.subheader("📷 Stereo Pipeline")
+    stereo = st.session_state.get("stereo_pipeline", {})
+    stereo_checks = {
+        "Data loaded":        "train_image" in stereo and "test_image" in stereo,
+        "ROI defined":        "roi" in stereo,
+        "Augmentation done":  "crop_aug" in stereo,
+        "Modules locked":     "active_modules" in stereo,
+        "Models trained":     "rce_head" in stereo,
+        "Detection run":      "rce_dets" in stereo,
+    }
+    for label, done in stereo_checks.items():
+        st.markdown(f"{'✅' if done else '⬜'} {label}")
+
+with col2:
+    st.subheader("🌍 Generalisation Pipeline")
+    gen = st.session_state.get("gen_pipeline", {})
+    gen_checks = {
+        "Data loaded":        "train_image" in gen and "test_image" in gen,
+        "ROI defined":        "roi" in gen,
+        "Augmentation done":  "crop_aug" in gen,
+        "Modules locked":     "active_modules" in gen,
+        "Models trained":     "rce_head" in gen,
+        "Detection run":      "rce_dets" in gen,
+    }
+    for label, done in gen_checks.items():
+        st.markdown(f"{'✅' if done else '⬜'} {label}")
+```
+
+---
+
+## Part 7 — Shared Utility Modules
+
+All core logic lives in `src/` and must be imported identically by both `tabs/stereo/` and `tabs/generalisation/` stages. Do not duplicate or move anything from `src/`.
+
+Key imports used by the stage files:
+```python
+from src.detectors.rce.features import RCEExtractor        # RCE feature extraction
+from src.detectors.resnet import ResNetDetector             # ResNet-18
+from src.detectors.mobilenet import MobileNetDetector       # MobileNetV3
+from src.detectors.mobilevit import MobileViTDetector       # MobileViT-XXS
+from src.detectors.orb import ORBDetector                   # ORB keypoint matching
+from src.detectors.yolo import YOLODetector                 # YOLOv8
+from src.localization import LocalizationStrategy           # All 5 localization strategies
+from src.models import load_model                           # Model loading from models/
+from src.config import *                                    # App constants
+```
+
+The `models/` directory contains pre-trained weights referenced by `src/models.py`. Do not move or rename any files in `models/`.
+
+---
+
+## Part 8 — Landing Page (Home)
+
+The existing landing page content in `app.py` must be preserved and rendered when `top_nav == "🏠 Home"`. Extract it into a `render_home()` function within `app.py`.
+
+Update the Pipeline Overview section to reflect the new two-pipeline structure:
+
+```
+🗺️ Pipeline Overview
+
+This platform provides two evaluation pipelines:
+
+📷 Stereo + Depth (7 stages)
+Train on the LEFT image, detect in the RIGHT image, estimate metric depth.
+Evaluates RCE in a constrained stereo-vision scenario.
+
+🌍 Generalisation (6 stages)  
+Train on one view/exposure, detect in a different view/exposure.
+Evaluates RCE's robustness to appearance variation.
+
+Both pipelines compare: RCE · ResNet-18 · MobileNetV3-Small · MobileViT-XXS · ORB
+```
+
+Update the bottom caption: *"Navigate using the sidebar → Choose a pipeline to begin"*
+
+---
+
+## Implementation Order
+
+Implement in this exact order to avoid breaking dependencies:
+
+1. `utils/middlebury_loader.py` — no dependencies, can be tested in isolation
+2. `app.py` — routing shell, import stubs for tabs not yet created
+3. `tabs/stereo/data_lab.py` — foundation of stereo pipeline
+4. `tabs/generalisation/data_lab.py` — foundation of generalisation pipeline
+5. Migrate existing stages into `tabs/stereo/` — feature_lab, model_tuning, localization, detection (with fix), evaluation, stereo_depth
+6. Create `tabs/generalisation/` stages — reuse stereo logic with gen_pipeline session keys
+7. Update home page session status widget
+
+---
+
+## What NOT To Change
+
+- **Entire `src/` directory** — all detector logic, RCE, CNN backbones, ORB, localization, model loading
+- **Entire `models/` directory** — pre-trained weights
+- **Entire `data/` directory** — Middlebury dataset
+- **`notebooks/`, `training/`, `scripts/`** — development artifacts, leave untouched
+- **`Dockerfile`, `packages.txt`, `requirements.txt`** — deployment config (add `streamlit-cropper` to requirements.txt only)
+- The visual style and markdown descriptions of each stage
+- The models description tabs on the home page (RCE, ResNet-18, MobileNetV3, MobileViT-XXS)
+- The depth estimation explanation and LaTeX formula
+
+---
+
+## Dependencies To Add
+
+Add to `requirements.txt` if not already present:
+```
+streamlit-cropper   # for ROI selection (optional but preferred)
+```
+
+No other new dependencies are needed. The Middlebury loader uses only `numpy`, `opencv-python`, `re`, `os`, and `pathlib` — all already present.
+
+---
+
+## Testing Checklist
+
+After implementation, verify:
+
+- [ ] Home page renders with both pipeline status widgets
+- [ ] Clicking "Stereo + Depth" shows 7-stage sub-navigation
+- [ ] Clicking "Generalisation" shows 6-stage sub-navigation
+- [ ] Clicking stages before Data Lab shows guard warning
+- [ ] Middlebury loader finds scenes from `./data/middlebury/`
+- [ ] Stereo Data Lab correctly assigns LEFT → train_image, RIGHT → test_image
+- [ ] Generalisation Data Lab correctly assigns View1 → train_image, View2 → test_image
+- [ ] Detection stage uses `pipe["test_image"]` in BOTH pipelines
+- [ ] Stereo and Generalisation pipelines do not share session state
+- [ ] Depth estimation gracefully disabled when calib is None
+- [ ] All existing stage logic works after migration

app.py

@@ -3,195 +3,211 @@ import streamlit as st
 st.set_page_config(page_title="Perception Benchmark", layout="wide", page_icon="🦅")
 
 # ===================================================================
-#  Header
+#  Routing — Sidebar Navigation
 # ===================================================================
-st.title("🦅 Recognition BenchMark")
-st.subheader("A stereo-vision pipeline for object recognition & depth estimation")
-st.caption("Compare classical feature engineering (RCE) against modern deep learning backbones — end-to-end, in your browser.")
+PIPELINES = {
+    "🏠 Home": None,
+    "📐 Stereo + Depth": {
+        "🧪 Data Lab":          "tabs.stereo.data_lab",
+        "🔬 Feature Lab":       "tabs.stereo.feature_lab",
+        "⚙️ Model Tuning":      "tabs.stereo.model_tuning",
+        "🔍 Localization Lab":  "tabs.stereo.localization",
+        "🎯 Real-Time Detection":"tabs.stereo.detection",
+        "📈 Evaluation":        "tabs.stereo.evaluation",
+        "📐 Stereo Geometry":   "tabs.stereo.stereo_depth",
+    },
+    "🌍 Generalisation": {
+        "🧪 Data Lab":          "tabs.generalisation.data_lab",
+        "🔬 Feature Lab":       "tabs.generalisation.feature_lab",
+        "⚙️ Model Tuning":      "tabs.generalisation.model_tuning",
+        "🔍 Localization Lab":  "tabs.generalisation.localization",
+        "🎯 Real-Time Detection":"tabs.generalisation.detection",
+        "📈 Evaluation":        "tabs.generalisation.evaluation",
+    },
+}
 
-st.divider()
+st.sidebar.title("🦅 Recognition BenchMark")
+pipeline_choice = st.sidebar.radio("Pipeline", list(PIPELINES.keys()), key="nav_pipeline")
+
+stage_module = None
+if PIPELINES[pipeline_choice] is not None:
+    stages_map = PIPELINES[pipeline_choice]
+    stage_choice = st.sidebar.radio("Stage", list(stages_map.keys()), key="nav_stage")
+    module_path = stages_map[stage_choice]
+    # dynamic import
+    import importlib
+    stage_module = importlib.import_module(module_path)
+
+# Session status widget (always visible in sidebar)
+st.sidebar.divider()
+st.sidebar.subheader("📋 Session Status")
+
+for pipe_label, pipe_key in [("Stereo", "stereo_pipeline"), ("General", "gen_pipeline")]:
+    pipe = st.session_state.get(pipe_key, {})
+    checks = {
+        "Data locked":   "train_image" in pipe,
+        "Crop defined":  "crop" in pipe,
+        "Modules set":   "active_modules" in pipe,
+        "RCE trained":   "rce_head" in pipe,
+        "CNN trained":   any(f"cnn_head_{n}" in pipe
+                             for n in ["ResNet-18", "MobileNetV3", "MobileViT-XXS"]),
+        "Dets ready":    "rce_dets" in pipe or "cnn_dets" in pipe,
+    }
+    with st.sidebar.expander(f"**{pipe_label}** — {sum(checks.values())}/{len(checks)}"):
+        for label, done in checks.items():
+            st.markdown(f"{'✅' if done else '⬜'} {label}")
 
 # ===================================================================
-#  Pipeline Overview
+#  Home Page
 # ===================================================================
-st.header("🗺️ Pipeline Overview")
-st.markdown("""
-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 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 = 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."),
-]
-
-for icon, title, desc in stages:
-    with st.container(border=True):
-        c1, c2 = st.columns([1, 12])
-        c1.markdown(f"## {icon}")
-        c2.markdown(f"**{title}**  \n{desc}")
-
-st.divider()
+def render_home():
+    st.title("🦅 Recognition BenchMark")
+    st.subheader("A stereo-vision pipeline for object recognition & depth estimation")
+    st.caption("Compare classical feature engineering (RCE) against modern deep learning backbones — end-to-end, in your browser.")
 
-# ===================================================================
-#  Models
-# ===================================================================
-st.header("🧠 Models Used")
+    st.divider()
 
-tab_rce, tab_resnet, tab_mobilenet, tab_mobilevit = st.tabs(
-    ["RCE Engine", "ResNet-18", "MobileNetV3-Small", "MobileViT-XXS"])
-
-with tab_rce:
-    st.markdown("### 🧬 RCE — Relative Contextual Encoding")
+    # -------------------------------------------------------------------
+    #  Two Pipelines
+    # -------------------------------------------------------------------
+    st.header("🗺️ Two Pipelines")
     st.markdown("""
-**Type:** Modular hand-crafted feature extractor  
-**Architecture:** Three physics-inspired modules, each producing a 10-bin histogram:
+    Choose a pipeline from the **sidebar**:
+
+    - **📐 Stereo + Depth** — 7 stages. Uses a stereo image pair (LEFT=train, RIGHT=test)
+      with calibration data and ground-truth disparities. Ends with metric depth estimation.
+    - **🌍 Generalisation** — 6 stages. Uses different scene *variants* from the Middlebury dataset
+      (train on one variant, test on another). Tests how well models generalise across viewpoints.
+    """)
+
+    col_s, col_g = st.columns(2)
+    with col_s:
+        st.markdown("### 📐 Stereo + Depth (7 stages)")
+        stereo_stages = [
+            ("🧪", "Data Lab",          "Load stereo pair, calib, GT depth. Define ROIs."),
+            ("🔬", "Feature Lab",        "Toggle RCE modules, compare CNN activations."),
+            ("⚙️", "Model Tuning",       "Train RCE / CNN / ORB heads."),
+            ("🔍", "Localization Lab",   "Compare 5 localization strategies."),
+            ("🎯", "Real-Time Detection","Sliding window on the TEST image."),
+            ("📈", "Evaluation",         "Confusion matrices, PR curves, F1."),
+            ("📐", "Stereo Geometry",    "StereoSGBM disparity → metric depth."),
+        ]
+        for icon, title, desc in stereo_stages:
+            st.markdown(f"{icon} **{title}** — {desc}")
+
+    with col_g:
+        st.markdown("### 🌍 Generalisation (6 stages)")
+        gen_stages = [
+            ("🧪", "Data Lab",          "Pick scene group & variants (train ≠ test)."),
+            ("🔬", "Feature Lab",        "Toggle RCE modules, compare CNN activations."),
+            ("⚙️", "Model Tuning",       "Train RCE / CNN / ORB heads."),
+            ("🔍", "Localization Lab",   "Compare 5 localization strategies."),
+            ("🎯", "Real-Time Detection","Sliding window on a different variant."),
+            ("📈", "Evaluation",         "Confusion matrices, PR curves, F1."),
+        ]
+        for icon, title, desc in gen_stages:
+            st.markdown(f"{icon} **{title}** — {desc}")
+
+    st.divider()
+
+    # -------------------------------------------------------------------
+    #  Models
+    # -------------------------------------------------------------------
+    st.header("🧠 Models Used")
+
+    tab_rce, tab_resnet, tab_mobilenet, tab_mobilevit = st.tabs(
+        ["RCE Engine", "ResNet-18", "MobileNetV3-Small", "MobileViT-XXS"])
+
+    with tab_rce:
+        st.markdown("### 🧬 RCE — Relative Contextual Encoding")
+        st.markdown("""
+**Type:** Modular hand-crafted feature extractor
+**Architecture:** Seven physics-inspired modules, each producing a 10-bin histogram:
 
 | Module | Input | Operation |
 |--------|-------|-----------|
 | **Intensity** | Grayscale | Pixel-value histogram (global appearance) |
 | **Sobel** | Gradient magnitude | Edge strength distribution (texture) |
 | **Spectral** | FFT log-magnitude | Frequency content (pattern / structure) |
-
-**Strengths:**
-- Fully explainable — every dimension has a physical meaning
-- Extremely fast (µs per patch, no GPU needed)
-- Modular: disable any module and immediately see the effect on the vector
-- Zero pre-training needed
-
-**Weakness:** Less discriminative than deep features for complex visual scenes.
-    """)
-
-with tab_resnet:
-    st.markdown("### 🏗️ ResNet-18")
-    st.markdown("""
-**Source:** PyTorch Hub (`torchvision.models.ResNet18_Weights.DEFAULT`)  
-**Pre-training:** ImageNet-1k (1.28 M images, 1 000 classes)  
-**Backbone output:** 512-dimensional embedding (after `avgpool`)  
+| **Laplacian** | Laplacian response | Second-derivative focus / sharpness |
+| **Gradient Orientation** | Sobel angles | Edge direction histogram |
+| **Gabor** | Multi-kernel response | Texture at multiple orientations / scales |
+| **LBP** | Local Binary Patterns | Micro-texture descriptor |
+
+Max feature vector = **70D** (7 modules × 10 bins).
+        """)
+
+    with tab_resnet:
+        st.markdown("### 🏗️ ResNet-18")
+        st.markdown("""
+**Source:** PyTorch Hub (`torchvision.models.ResNet18_Weights.DEFAULT`)
+**Pre-training:** ImageNet-1k (1.28 M images, 1 000 classes)
+**Backbone output:** 512-dimensional embedding (after `avgpool`)
 **Head:** LogisticRegression trained on your session data
 
-**Architecture highlights:**
-- 18 layers with residual (skip) connections
-- Residual blocks prevent vanishing gradients in deeper networks
-- `layer4` is hooked for activation map visualisation
-
-**In this app:** The entire backbone is **frozen** (`requires_grad=False`).  
+**In this app:** The entire backbone is **frozen** (`requires_grad=False`).
 Only the lightweight head adapts to your specific object.
-    """)
-
-with tab_mobilenet:
-    st.markdown("### 📱 MobileNetV3-Small")
-    st.markdown("""
-**Source:** PyTorch Hub (`torchvision.models.MobileNet_V3_Small_Weights.DEFAULT`)  
-**Pre-training:** ImageNet-1k  
-**Backbone output:** 576-dimensional embedding (classifier replaced with `Identity`)  
+        """)
+
+    with tab_mobilenet:
+        st.markdown("### 📱 MobileNetV3-Small")
+        st.markdown("""
+**Source:** PyTorch Hub (`torchvision.models.MobileNet_V3_Small_Weights.DEFAULT`)
+**Pre-training:** ImageNet-1k
+**Backbone output:** 576-dimensional embedding
 **Head:** LogisticRegression trained on your session data
 
-**Architecture highlights:**
-- Inverted residuals + linear bottlenecks (MobileNetV2 heritage)
-- Hard-Swish / Hard-Sigmoid activations (hardware-friendly)
-- Squeeze-and-Excitation (SE) blocks for channel attention
-- Designed for **edge / mobile inference** — ~2.5 M parameters
+**In this app:** Typically 3–5× faster than ResNet-18.
+        """)
 
-**In this app:** Typically 3–5× faster than ResNet-18.  
-`features[-1]` is hooked for activation maps.
-    """)
-
-with tab_mobilevit:
-    st.markdown("### 🤖 MobileViT-XXS")
-    st.markdown("""
-**Source:** timm — `mobilevit_xxs.cvnets_in1k` (Apple Research, 2022)  
-**Pre-training:** ImageNet-1k  
-**Backbone output:** 320-dimensional embedding (`num_classes=0`)  
+    with tab_mobilevit:
+        st.markdown("### 🤖 MobileViT-XXS")
+        st.markdown("""
+**Source:** timm — `mobilevit_xxs.cvnets_in1k` (Apple Research, 2022)
+**Pre-training:** ImageNet-1k
+**Backbone output:** 320-dimensional embedding (`num_classes=0`)
 **Head:** LogisticRegression trained on your session data
 
-**Architecture highlights:**
-- **Hybrid CNN + Vision Transformer** — local convolutions for spatial features,
-  global self-attention for long-range context
-- MobileNetV2 stem + MobileViT blocks (attention on non-overlapping patches)
-- Only ~1.3 M parameters — smallest of the three
-
-**In this app:** The final transformer stage `stages[-1]` is hooked.  
-Slower than MobileNetV3 but captures global structure.
-    """)
+**In this app:** Hybrid CNN + Vision Transformer. Only ~1.3 M parameters.
+        """)
 
-st.divider()
+    st.divider()
 
-# ===================================================================
-#  Depth Estimation
-# ===================================================================
-st.header("📐 Stereo Depth Estimation")
+    # -------------------------------------------------------------------
+    #  Depth Estimation
+    # -------------------------------------------------------------------
+    st.header("📐 Stereo Depth Estimation")
 
-col_d1, col_d2 = st.columns(2)
-with col_d1:
-    st.markdown("""
+    col_d1, col_d2 = st.columns(2)
+    with col_d1:
+        st.markdown("""
 **Algorithm:** `cv2.StereoSGBM` (Semi-Global Block Matching)
 
 SGBM minimises a global energy function combining:
 - Data cost (pixel intensity difference)
 - Smoothness penalty (P1, P2 regularisation)
 
-It processes multiple horizontal and diagonal scan-line passes, 
+It processes multiple horizontal and diagonal scan-line passes,
 making it significantly more accurate than basic block matching.
-    """)
-with col_d2:
-    st.markdown("""
-**Depth formula (Middlebury convention):**
-    """)
-    st.latex(r"Z = \frac{f \times B}{d + d_{\text{offs}}}")
-    st.markdown("""
-- $f$ — focal length (pixels)  
-- $B$ — baseline (mm, from calibration file)  
-- $d$ — disparity (pixels)  
+        """)
+    with col_d2:
+        st.markdown("**Depth formula (Middlebury convention):**")
+        st.latex(r"Z = \frac{f \times B}{d + d_{\text{offs}}}")
+        st.markdown("""
+- $f$ — focal length (pixels)
+- $B$ — baseline (mm, from calibration file)
+- $d$ — disparity (pixels)
 - $d_\\text{offs}$ — optical-center offset between cameras
-    """)
+        """)
+
+    st.divider()
+    st.caption("Select a pipeline from the **sidebar** to begin.")
 
-st.divider()
 
 # ===================================================================
-#  Session Status
+#  Dispatch
 # ===================================================================
-st.header("📋 Session Status")
-
-pipe = st.session_state.get("pipeline_data", {})
-
-checks = {
-    "Data Lab locked":       "left" in pipe,
-    "Crop defined":          "crop" in pipe,
-    "Augmentation applied":  "crop_aug" in pipe,
-    "Active modules locked": "active_modules" in st.session_state,
-    "RCE head trained":      "rce_head" in st.session_state,
-    "CNN head trained":      any(f"cnn_head_{n}" in st.session_state
-                                  for n in ["ResNet-18", "MobileNetV3", "MobileViT-XXS"]),
-    "RCE detections ready":  "rce_dets" in st.session_state,
-    "CNN detections ready":  "cnn_dets" in st.session_state,
-}
-
-cols = st.columns(4)
-for i, (label, done) in enumerate(checks.items()):
-    cols[i % 4].markdown(
-        f"{'✅' if done else '⬜'} {'~~' if not done else ''}{label}{'~~' if not done else ''}"
-    )
-
-st.divider()
-st.caption("Navigate using the sidebar → Start with **🧪 Data Lab**")
+if stage_module is not None:
+    stage_module.render()
+else:
+    render_home()

dataOLD/README.md

@@ -0,0 +1,5 @@
+two data views: 
+
+- Classification (ResNet, MobileNet, RCE)
+- Detection (YOLO)
+

dataOLD/artroom/bird/yolo/bird_data.yaml

@@ -0,0 +1,7 @@
+path: /Users/dariusgiannoli/Desktop/Recognition-BenchMark/data/artroom/bird/yolo
+train: train/images
+val: train/images
+
+# Classes
+nc: 1
+names: ['bird']

dataOLD/artroom/bird/yolo/train/labels/bird_01_original.txt

@@ -0,0 +1 @@
+0 0.5 0.5 0.8 0.8

dataOLD/artroom/bird/yolo/train/labels/bird_02_rot_pos5.txt

@@ -0,0 +1 @@
+0 0.5 0.5 0.8 0.8

dataOLD/artroom/bird/yolo/train/labels/bird_03_rot_neg5.txt

@@ -0,0 +1 @@
+0 0.5 0.5 0.8 0.8

dataOLD/artroom/bird/yolo/train/labels/bird_04_bright.txt

@@ -0,0 +1 @@
+0 0.5 0.5 0.8 0.8

dataOLD/artroom/bird/yolo/train/labels/bird_05_dark.txt

@@ -0,0 +1 @@
+0 0.5 0.5 0.8 0.8

dataOLD/artroom/bird/yolo/train/labels/bird_06_noisy.txt

@@ -0,0 +1 @@
+0 0.5 0.5 0.8 0.8

dataOLD/artroom/bird/yolo/train/labels/bird_07_flip.txt

@@ -0,0 +1 @@
+0 0.5 0.5 0.8 0.8

dataOLD/artroom/bird/yolo/train/labels/bird_08_blur.txt

@@ -0,0 +1 @@
+0 0.5 0.5 0.8 0.8

dataOLD/artroom/bird/yolo/train/labels/bird_09_shift_x.txt

@@ -0,0 +1 @@
+0 0.5 0.5 0.8 0.8

dataOLD/artroom/bird/yolo/train/labels/bird_10_shift_y.txt

@@ -0,0 +1 @@
+0 0.5 0.5 0.8 0.8

pages/2_Data_Lab.py

@@ -1,321 +0,0 @@
-import streamlit as st
-import cv2
-import numpy as np
-import io
-
-st.set_page_config(page_title="Data Lab", layout="wide")
-
-st.title("🧪 Data Lab: Stereo Asset Loader")
-st.write("Upload your stereo images, camera configuration, and ground truth depth maps.")
-
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-def read_pfm(file_bytes: bytes) -> np.ndarray:
-    """Parse a PFM (Portable Float Map) and return a float32 ndarray."""
-    buf = io.BytesIO(file_bytes)
-    header = buf.readline().decode("ascii").strip()
-    if header not in ("Pf", "PF"):
-        raise ValueError(f"Not a valid PFM file (header: {header!r})")
-    color = header == "PF"
-    line = buf.readline().decode("ascii").strip()
-    while line.startswith("#"):
-        line = buf.readline().decode("ascii").strip()
-    w, h = map(int, line.split())
-    scale = float(buf.readline().decode("ascii").strip())
-    endian = "<" if scale < 0 else ">"
-    channels = 3 if color else 1
-    data = np.frombuffer(buf.read(), dtype=np.dtype(endian + "f4"))
-    data = data.reshape((h, w, channels) if color else (h, w))
-    return np.flipud(data)
-
-
-def vis_depth(depth: np.ndarray) -> np.ndarray:
-    """Normalise depth to [0,1] for display, ignoring non-finite values."""
-    finite = depth[np.isfinite(depth)]
-    d = np.nan_to_num(depth, nan=0.0, posinf=float(finite.max()))
-    return (d / d.max()).astype(np.float32) if d.max() > 0 else d.astype(np.float32)
-
-
-def augment(img: np.ndarray, brightness: float, contrast: float,
-            rotation: float, flip_h: bool, flip_v: bool,
-            noise: float, blur: int, shift_x: int, shift_y: int) -> np.ndarray:
-    """Apply a chain of augmentations to a BGR crop."""
-    out = img.astype(np.float32)
-
-    # Brightness / Contrast:  out = contrast * out + brightness_offset
-    out = np.clip(contrast * out + brightness, 0, 255)
-
-    # Gaussian noise
-    if noise > 0:
-        out = np.clip(out + np.random.normal(0, noise, out.shape), 0, 255)
-
-    out = out.astype(np.uint8)
-
-    # Blur (kernel must be odd)
-    k = blur * 2 + 1
-    if k > 1:
-        out = cv2.GaussianBlur(out, (k, k), 0)
-
-    # Rotation
-    if rotation != 0:
-        h, w = out.shape[:2]
-        M = cv2.getRotationMatrix2D((w / 2, h / 2), rotation, 1.0)
-        out = cv2.warpAffine(out, M, (w, h), borderMode=cv2.BORDER_REFLECT)
-
-    # Translation
-    if shift_x != 0 or shift_y != 0:
-        h, w = out.shape[:2]
-        M = np.float32([[1, 0, shift_x], [0, 1, shift_y]])
-        out = cv2.warpAffine(out, M, (w, h), borderMode=cv2.BORDER_REFLECT)
-
-    # Flips
-    if flip_h:
-        out = cv2.flip(out, 1)
-    if flip_v:
-        out = cv2.flip(out, 0)
-
-    return out
-
-
-# --- Session State Initialization ---
-MAX_UPLOAD_BYTES = 50 * 1024 * 1024  # 50 MB
-
-if "pipeline_data" not in st.session_state:
-    st.session_state["pipeline_data"] = {}
-
-# ---------------------------------------------------------------------------
-# Step 1 — Upload Assets
-# ---------------------------------------------------------------------------
-st.subheader("Step 1: Upload Assets")
-col1, col2 = st.columns(2)
-
-with col1:
-    up_l = st.file_uploader("Left Image (Reference)", type=["png", "jpg", "jpeg"])
-    if up_l:
-        if up_l.size > MAX_UPLOAD_BYTES:
-            st.error(f"❌ Left image too large ({up_l.size / 1e6:.1f} MB). Max 50 MB.")
-            up_l = None
-        else:
-            img_l_preview = cv2.imdecode(np.frombuffer(up_l.read(), np.uint8), cv2.IMREAD_COLOR)
-            up_l.seek(0)
-            st.image(cv2.cvtColor(img_l_preview, cv2.COLOR_BGR2RGB), caption="Left Image Preview", use_container_width=True)
-
-    up_conf = st.file_uploader("Camera Config (.txt or .conf)", type=["txt", "conf"])
-
-    up_gt_l = st.file_uploader("Left Ground Truth Depth (.pfm)", type=["pfm"])
-    if up_gt_l:
-        try:
-            gt_l_prev = read_pfm(up_gt_l.read());  up_gt_l.seek(0)
-            st.image(vis_depth(gt_l_prev), caption="Left GT Depth Preview", use_container_width=True)
-        except (ValueError, Exception) as e:
-            st.error(f"❌ Invalid PFM file (left): {e}")
-            up_gt_l = None
-
-with col2:
-    up_r = st.file_uploader("Right Image (Stereo Match)", type=["png", "jpg", "jpeg"])
-    if up_r:
-        if up_r.size > MAX_UPLOAD_BYTES:
-            st.error(f"❌ Right image too large ({up_r.size / 1e6:.1f} MB). Max 50 MB.")
-            up_r = None
-        else:
-            img_r_preview = cv2.imdecode(np.frombuffer(up_r.read(), np.uint8), cv2.IMREAD_COLOR)
-            up_r.seek(0)
-            st.image(cv2.cvtColor(img_r_preview, cv2.COLOR_BGR2RGB), caption="Right Image Preview", use_container_width=True)
-
-    up_gt_r = st.file_uploader("Right Ground Truth Depth (.pfm)", type=["pfm"])
-    if up_gt_r:
-        try:
-            gt_r_prev = read_pfm(up_gt_r.read());  up_gt_r.seek(0)
-            st.image(vis_depth(gt_r_prev), caption="Right GT Depth Preview", use_container_width=True)
-        except (ValueError, Exception) as e:
-            st.error(f"❌ Invalid PFM file (right): {e}")
-            up_gt_r = None
-
-# ---------------------------------------------------------------------------
-# Step 2 — Full pipeline (requires all 5 files)
-# ---------------------------------------------------------------------------
-if up_l and up_r and up_conf and up_gt_l and up_gt_r:
-    img_l       = cv2.imdecode(np.frombuffer(up_l.read(),    np.uint8), cv2.IMREAD_COLOR)
-    img_r       = cv2.imdecode(np.frombuffer(up_r.read(),    np.uint8), cv2.IMREAD_COLOR)
-    conf_content = up_conf.read().decode("utf-8")
-    gt_depth_l  = read_pfm(up_gt_l.read())
-    gt_depth_r  = read_pfm(up_gt_r.read())
-
-    st.success("✅ All assets loaded successfully!")
-
-    # --- Stereo pair ---
-    st.divider()
-    st.subheader("Step 2: Asset Visualization")
-    st.write("### 📸 Stereo Pair")
-    v1, v2 = st.columns(2)
-    v1.image(cv2.cvtColor(img_l, cv2.COLOR_BGR2RGB), caption="Left View", use_container_width=True)
-    v2.image(cv2.cvtColor(img_r, cv2.COLOR_BGR2RGB), caption="Right View", use_container_width=True)
-
-    # --- Ground truth maps ---
-    st.write("### 📊 Ground Truth Depth Maps")
-    d1, d2 = st.columns(2)
-    d1.image(vis_depth(gt_depth_l), caption="Left GT Depth (Normalized)", use_container_width=True)
-    d2.image(vis_depth(gt_depth_r), caption="Right GT Depth (Normalized)", use_container_width=True)
-
-    # --- Config ---
-    with st.expander("📄 Camera Configuration"):
-        st.text_area("Raw Config", conf_content, height=200)
-
-    # -----------------------------------------------------------------------
-    # Step 3 — Crop ROI(s) from Left Image  (Multi-Object)
-    # -----------------------------------------------------------------------
-    st.divider()
-    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]
-
-    # 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():
-        if len(st.session_state["rois"]) >= 20:
-            return
-        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,
-              disabled=len(st.session_state["rois"]) >= 20)
-
-    # Draw all ROIs on the image
-    overlay = img_l.copy()
-    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 — 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
-    # -----------------------------------------------------------------------
-    st.divider()
-    st.subheader("Step 4: Data Augmentation")
-    st.write("Tune the parameters below — the augmented crop updates live.")
-
-    ac1, ac2 = st.columns(2)
-    with ac1:
-        brightness = st.slider("Brightness offset",  -100, 100,  0, step=1)
-        contrast   = st.slider("Contrast scale",      0.5,  3.0, 1.0, step=0.05)
-        rotation   = st.slider("Rotation (°)",        -180, 180,  0, step=1)
-        noise      = st.slider("Gaussian noise σ",     0,   50,   0, step=1)
-    with ac2:
-        blur       = st.slider("Blur kernel (0 = off)", 0,  10,   0, step=1)
-        shift_x    = st.slider("Shift X (px)",         -100, 100,  0, step=1)
-        shift_y    = st.slider("Shift Y (px)",         -100, 100,  0, step=1)
-        flip_h     = st.checkbox("Flip Horizontal")
-        flip_v     = st.checkbox("Flip Vertical")
-
-    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 (ROI 1)", use_container_width=True)
-    aug_col2.image(cv2.cvtColor(aug, cv2.COLOR_BGR2RGB),
-                   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"):
-        if not st.session_state.get("rois") or len(st.session_state["rois"]) == 0:
-            st.error("❌ Define at least one ROI before locking!")
-            st.stop()
-        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(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/3_Feature_Lab.py

@@ -1,111 +0,0 @@
-import streamlit as st
-import cv2
-import numpy as np
-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
-
-st.set_page_config(page_title="Feature Lab", layout="wide")
-
-if "pipeline_data" not in st.session_state:
-    st.error("Please complete the Data Lab first!")
-    st.stop()
-
-assets = st.session_state["pipeline_data"]
-# Use augmented crop if available, otherwise fall back to original crop
-obj = assets.get("crop_aug", assets.get("crop"))
-if obj is None:
-    st.error("No crop found. Please go back to Data Lab and define a ROI.")
-    st.stop()
-gray = cv2.cvtColor(obj, cv2.COLOR_BGR2GRAY)
-
-st.title("🔬 Feature Lab: Physical Module Selection")
-
-col_rce, col_cnn = st.columns([3, 2])
-
-# ---------------------------------------------------------------------------
-# LEFT — RCE Modular Engine (pure UI — all math lives in features.py)
-# ---------------------------------------------------------------------------
-with col_rce:
-    st.header("🧬 RCE: Modular Physics Engine")
-    st.subheader("Select Active Modules")
-
-    # Dynamically build checkboxes from the registry (rows of 4)
-    active = {}
-    items = list(REGISTRY.items())
-    for row_start in range(0, len(items), 4):
-        row_items = items[row_start:row_start + 4]
-        m_cols = st.columns(4)
-        for col, (key, meta) in zip(m_cols, row_items):
-            active[key] = col.checkbox(meta["label"], value=(key in ("intensity", "sobel", "spectral")))
-
-    # Build vector + collect visualizations by calling registry functions
-    final_vector = []
-    viz_images = []
-    for key, meta in REGISTRY.items():
-        if active[key]:
-            vec, viz = meta["fn"](gray)
-            final_vector.extend(vec)
-            viz_images.append((meta["viz_title"], viz))
-
-    # Visualizations (rows of 3)
-    st.divider()
-    if viz_images:
-        for row_start in range(0, len(viz_images), 3):
-            row = viz_images[row_start:row_start + 3]
-            v_cols = st.columns(3)
-            for col, (title, img) in zip(v_cols, row):
-                col.image(img, caption=title, use_container_width=True)
-    else:
-        st.warning("No modules selected — vector is empty.")
-
-    # DNA vector bar chart
-    st.write(f"### Current DNA Vector Size: **{len(final_vector)}**")
-    fig_vec = go.Figure(data=[go.Bar(y=final_vector, marker_color="#00d4ff")])
-    fig_vec.update_layout(title="Active Feature Vector (RCE Input)",
-                          template="plotly_dark", height=300)
-    st.plotly_chart(fig_vec, use_container_width=True)
-
-# ---------------------------------------------------------------------------
-# RIGHT — CNN comparison panel
-# ---------------------------------------------------------------------------
-with col_cnn:
-    st.header("🧠 CNN: Static Architecture")
-    selected_cnn = st.selectbox("Compare against Model", list(BACKBONES.keys()))
-    st.info("CNN features are fixed by pre-trained weights. You cannot toggle them like the RCE.")
-
-    with st.spinner(f"Loading {selected_cnn} and extracting activations..."):
-        try:
-            bmeta = BACKBONES[selected_cnn]
-            backbone = bmeta["loader"]()       # cached frozen backbone
-            layer_name = bmeta["hook_layer"]
-
-            act_maps = backbone.get_activation_maps(obj, n_maps=6)
-            st.caption(f"Hooked layer: `{layer_name}` — showing 6 of {len(act_maps)} channels")
-            act_cols = st.columns(3)
-            for i, amap in enumerate(act_maps):
-                act_cols[i % 3].image(amap, caption=f"Channel {i}", use_container_width=True)
-
-        except Exception as e:
-            st.error(f"Could not load model: {e}")
-
-    st.divider()
-    st.markdown(f"""
-    **Analysis:**
-    - **Modularity:** RCE is **High** | CNN is **Zero**
-    - **Explainability:** RCE is **High** | CNN is **Low**
-    - **Compute Cost:** {len(final_vector)} floats | 512+ floats
-    """)
-
-# ---------------------------------------------------------------------------
-# Lock configuration
-# ---------------------------------------------------------------------------
-if st.button("🚀 Lock Modular Configuration"):
-    if not final_vector:
-        st.error("Please select at least one module!")
-    else:
-        st.session_state["pipeline_data"]["final_vector"] = np.array(final_vector)
-        st.session_state["active_modules"] = {k: v for k, v in active.items()}
-        st.success("Modular DNA Locked! Ready for Model Tuning.")

pages/4_Model_Tuning.py

@@ -1,475 +0,0 @@
-import streamlit as st
-import cv2
-import numpy as np
-import time
-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.utils import build_rce_vector
-
-st.set_page_config(page_title="Model Tuning", layout="wide")
-st.title("⚙️ Model Tuning: Train & Compare")
-
-# ---------------------------------------------------------------------------
-# Guard: require Data Lab completion
-# ---------------------------------------------------------------------------
-if "pipeline_data" not in st.session_state or "crop" not in st.session_state.get("pipeline_data", {}):
-    st.error("Please complete the **Data Lab** first (upload assets & define a crop).")
-    st.stop()
-
-assets = st.session_state["pipeline_data"]
-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():
-    """
-    Multi-class aware training set builder.
-    Positive samples per class: original crop + augmented crop.
-    Negative samples: random patches that don't overlap ANY ROI.
-    """
-    images = []
-    labels = []
-
-    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]
-    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
-    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))
-        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]
-        if patch.shape[0] > 0 and patch.shape[1] > 0:
-            negatives.append(patch)
-        attempts += 1
-
-    images.extend(negatives)
-    labels.extend(["background"] * len(negatives))
-    return images, labels, len(negatives) < n_neg_target // 2
-
-
-# ===================================================================
-# Show training data
-# ===================================================================
-st.subheader("Training Data (from Data Lab)")
-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: RCE  |  CNN  |  ORB
-# ===================================================================
-col_rce, col_cnn, col_orb = st.columns(3)
-
-# ---------------------------------------------------------------------------
-# LEFT — RCE Training
-# ---------------------------------------------------------------------------
-with col_rce:
-    st.header("🧬 RCE Training")
-
-    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.")
-    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, neg_short = build_training_set()
-            if neg_short:
-                st.warning(f"⚠️ Only {sum(1 for l in labels if l == 'background')} "
-                           f"negatives collected (target was {sum(1 for l in labels if l != 'background') * 2}). "
-                           f"Training data may be imbalanced.")
-            from sklearn.metrics import accuracy_score
-            from sklearn.model_selection import cross_val_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, active_modules))
-                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()
-            try:
-                head = RecognitionHead(C=rce_C, max_iter=rce_max_iter).fit(X, labels)
-            except ValueError as e:
-                st.error(f"Training failed: {e}")
-                st.stop()
-            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, m4 = st.columns(4)
-            m1.metric("Train Accuracy", f"{train_acc:.1%}")
-            # Cross-validation (only if enough samples)
-            if len(images) >= 6:
-                n_splits = min(5, len(set(labels)))
-                if n_splits >= 2:
-                    cv_scores = cross_val_score(head.model, X, labels,
-                                               cv=min(3, len(images) // 2))
-                    m2.metric("CV Accuracy", f"{cv_scores.mean():.1%}",
-                              delta=f"±{cv_scores.std():.1%}")
-                else:
-                    m2.metric("CV Accuracy", "N/A")
-            else:
-                m2.metric("CV Accuracy", "N/A")
-            m3.metric("Vector Size", f"{X.shape[1]} floats")
-            m4.metric("Samples", f"{len(images)}")
-            if len(images) < 10:
-                st.warning("⚠️ Training set is small (<10 samples). "
-                           "Reported accuracy may not reflect real performance.")
-            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, active_modules)
-            label, conf = head.predict(vec)
-            dt = (time.perf_counter() - t0) * 1000
-            st.write(f"**{label}** — {conf:.1%} confidence — {dt:.1f} ms")
-
-
-# ---------------------------------------------------------------------------
-# MIDDLE — CNN Fine-Tuning
-# ---------------------------------------------------------------------------
-with col_cnn:
-    st.header("🧠 CNN Fine-Tuning")
-
-    selected = st.selectbox("Select Model", list(BACKBONES.keys()))
-    meta = BACKBONES[selected]
-    st.caption(f"Backbone embedding: **{meta['dim']}D** → Logistic Regression head")
-
-    st.subheader("Training Parameters")
-    cnn_C = st.slider("Regularization (C) ", 0.01, 10.0, 1.0, step=0.01,
-                       key="cnn_c", help="Higher = less regularization")
-    cnn_max_iter = st.slider("Max Iterations ", 100, 5000, 1000, step=100,
-                              key="cnn_iter")
-
-    if st.button(f"🚀 Train {selected} Head"):
-        images, labels, neg_short = build_training_set()
-        if neg_short:
-            st.warning(f"⚠️ Negative sample shortfall — training may be imbalanced.")
-        backbone = meta["loader"]()
-
-        from sklearn.metrics import accuracy_score
-        from sklearn.model_selection import cross_val_score
-
-        progress = st.progress(0, text=f"Extracting {selected} features...")
-        n = len(images)
-        X = []
-        for i, img in enumerate(images):
-            X.append(backbone.get_features(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()
-        try:
-            head = RecognitionHead(C=cnn_C, max_iter=cnn_max_iter).fit(X, labels)
-        except ValueError as e:
-            st.error(f"Training failed: {e}")
-            st.stop()
-        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, m4 = st.columns(4)
-        m1.metric("Train Accuracy", f"{train_acc:.1%}")
-        if len(images) >= 6:
-            n_splits = min(5, len(set(labels)))
-            if n_splits >= 2:
-                cv_scores = cross_val_score(head.model, X, labels,
-                                           cv=min(3, len(images) // 2))
-                m2.metric("CV Accuracy", f"{cv_scores.mean():.1%}",
-                          delta=f"±{cv_scores.std():.1%}")
-            else:
-                m2.metric("CV Accuracy", "N/A")
-        else:
-            m2.metric("CV Accuracy", "N/A")
-        m3.metric("Vector Size", f"{X.shape[1]}D")
-        m4.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)
-
-        # ---- 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"]()
-        head = st.session_state[f"cnn_head_{selected}"]
-        t0 = time.perf_counter()
-        feats = backbone.get_features(crop_aug)
-        label, conf = head.predict(feats)
-        dt = (time.perf_counter() - t0) * 1000
-        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")
-
-rows = []
-rce_acc = st.session_state.get("rce_train_acc")
-if rce_acc is not None:
-    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, "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
-    st.dataframe(pd.DataFrame(rows), use_container_width=True, hide_index=True)
-else:
-    st.info("Train at least one model to see the comparison.")

pages/5_Localization_Lab.py

@@ -1,348 +0,0 @@
-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.utils import build_rce_vector
-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
-
-if win_h <= 0 or win_w <= 0:
-    st.error("Invalid window size from crop bbox. "
-             "Go back to **Data Lab** and redefine the ROI.")
-    st.stop()
-
-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):
-    return build_rce_vector(patch_bgr, active_mods)
-
-
-# ===================================================================
-#  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/6_RealTime_Detection.py

@@ -1,435 +0,0 @@
-import streamlit as st
-import cv2
-import numpy as np
-import time
-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.utils import build_rce_vector
-from src.localization import nms as _nms, _iou
-
-st.set_page_config(page_title="Real-Time Detection", layout="wide")
-st.title("🎯 Real-Time Detection")
-
-# ---------------------------------------------------------------------------
-# 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]))
-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
-
-if win_h <= 0 or win_w <= 0:
-    st.error("Invalid window size from crop bbox. "
-             "Go back to **Data Lab** and redefine the ROI.")
-    st.stop()
-
-# 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 and not has_orb:
-    st.warning("No trained heads found. Go to **Model Tuning** and train at least one head.")
-    st.stop()
-
-
-# ===================================================================
-#  Sliding Window Engine  (shared by both sides)
-# ===================================================================
-def sliding_window_detect(
-    image: np.ndarray,
-    feature_fn,          # callable(patch_bgr) -> 1-D np.ndarray
-    head: RecognitionHead,
-    stride: int,
-    conf_thresh: float,
-    nms_iou: float,
-    progress_placeholder=None,
-    live_image_placeholder=None,
-):
-    """
-    Slide a window of size (win_h, win_w) across *image* with *stride*.
-    At each position call *feature_fn* → *head.predict*.
-    Returns (detections, heatmap, total_time_ms, n_windows).
-
-    Each detection is (x, y, x+win_w, y+win_h, label, confidence).
-    heatmap is a float32 array same size as image (object confidence).
-    """
-    H, W = image.shape[:2]
-    heatmap = np.zeros((H, W), dtype=np.float32)
-    detections = []
-    t0 = time.perf_counter()
-
-    positions = []
-    for y in range(0, H - win_h + 1, stride):
-        for x in range(0, W - win_w + 1, stride):
-            positions.append((x, y))
-
-    n_total = len(positions)
-    if n_total == 0:
-        return [], heatmap, 0.0, 0
-
-    for idx, (x, y) in enumerate(positions):
-        patch = image[y:y+win_h, x:x+win_w]
-        feats = feature_fn(patch)
-        label, conf = head.predict(feats)
-
-        # 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:
-                detections.append((x, y, x+win_w, y+win_h, label, conf))
-
-        # Live updates (every 5th window or last)
-        if live_image_placeholder is not None and (idx % 5 == 0 or idx == n_total - 1):
-            vis = image.copy()
-            # Draw current scan position
-            cv2.rectangle(vis, (x, y), (x+win_w, y+win_h), (255, 255, 0), 1)
-            # Draw current detections
-            for dx, dy, dx2, dy2, dl, dc in detections:
-                cv2.rectangle(vis, (dx, dy), (dx2, dy2), (0, 255, 0), 2)
-                cv2.putText(vis, f"{dc:.0%}", (dx, dy - 4),
-                            cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 255, 0), 1)
-            live_image_placeholder.image(
-                cv2.cvtColor(vis, cv2.COLOR_BGR2RGB),
-                caption=f"Scanning… {idx+1}/{n_total}",
-                use_container_width=True)
-
-        if progress_placeholder is not None:
-            progress_placeholder.progress(
-                (idx + 1) / n_total,
-                text=f"Window {idx+1}/{n_total}")
-
-    total_ms = (time.perf_counter() - t0) * 1000
-
-    # --- Non-Maximum Suppression ---
-    if detections:
-        detections = _nms(detections, nms_iou)
-
-    return detections, heatmap, total_ms, n_total
-
-
-# ===================================================================
-#  RCE feature function
-# ===================================================================
-def rce_feature_fn(patch_bgr):
-    return build_rce_vector(patch_bgr, active_mods)
-
-
-# ===================================================================
-#  Controls
-# ===================================================================
-st.subheader("Sliding Window Parameters")
-p1, p2, p3 = st.columns(3)
-stride = p1.slider("Stride (px)", 4, max(win_w // 2, 4),
-                    max(win_w // 4, 4), step=2,
-                    help="Lower = more windows = slower but finer")
-conf_thresh = p2.slider("Confidence Threshold", 0.5, 1.0, 0.7, 0.05)
-nms_iou = p3.slider("NMS IoU Threshold", 0.1, 0.9, 0.3, 0.05)
-
-st.caption(f"Window size: **{win_w}×{win_h} px**  |  "
-           f"Right image: **{right_img.shape[1]}×{right_img.shape[0]} px**  |  "
-           f"≈ {((right_img.shape[0]-win_h)//stride + 1) * ((right_img.shape[1]-win_w)//stride + 1)} windows")
-
-st.divider()
-
-# ===================================================================
-#  Side-by-side layout
-# ===================================================================
-col_rce, col_cnn, col_orb = st.columns(3)
-
-# -------------------------------------------------------------------
-#  LEFT — RCE Detection
-# -------------------------------------------------------------------
-with col_rce:
-    st.header("🧬 RCE Detection")
-    if rce_head is None:
-        st.info("No RCE head trained. Train one in **Model Tuning**.")
-    else:
-        st.caption(f"Modules: {', '.join(REGISTRY[k]['label'] for k in active_mods if active_mods[k])}")
-        rce_run = st.button("▶ Run RCE Scan", key="rce_run")
-
-        rce_progress = st.empty()
-        rce_live     = st.empty()
-        rce_results  = st.container()
-
-        if rce_run:
-            dets, hmap, ms, nw = sliding_window_detect(
-                right_img, rce_feature_fn, rce_head,
-                stride, conf_thresh, nms_iou,
-                progress_placeholder=rce_progress,
-                live_image_placeholder=rce_live,
-            )
-
-            # 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:
-                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)
-            rce_progress.empty()
-
-            with rce_results:
-                # Metrics
-                rm1, rm2, rm3, rm4 = st.columns(4)
-                rm1.metric("Detections", len(dets))
-                rm2.metric("Windows", nw)
-                rm3.metric("Total Time", f"{ms:.0f} ms")
-                rm4.metric("Per Window", f"{ms/max(nw,1):.2f} ms")
-
-                # Confidence 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)
-                    st.image(cv2.cvtColor(blend, cv2.COLOR_BGR2RGB),
-                             caption="RCE — Confidence Heatmap",
-                             use_container_width=True)
-
-                # Detection table
-                if dets:
-                    import pandas as pd
-                    df = pd.DataFrame(dets, columns=["x1","y1","x2","y2","label","conf"])
-                    st.dataframe(df, use_container_width=True, hide_index=True)
-
-            st.session_state["rce_dets"] = dets
-            st.session_state["rce_det_ms"] = ms
-
-# -------------------------------------------------------------------
-#  RIGHT — CNN Detection
-# -------------------------------------------------------------------
-with col_cnn:
-    st.header("🧠 CNN Detection")
-
-    # Find which CNN heads are trained
-    trained_cnns = [n for n in BACKBONES if f"cnn_head_{n}" in st.session_state]
-    if not trained_cnns:
-        st.info("No CNN head trained. Train one in **Model Tuning**.")
-    else:
-        selected = st.selectbox("Select Model", trained_cnns, key="det_cnn_sel")
-        bmeta    = BACKBONES[selected]
-        backbone = bmeta["loader"]()
-        head     = st.session_state[f"cnn_head_{selected}"]
-
-        st.caption(f"Backbone: **{selected}** ({bmeta['dim']}D) — Head in session state")
-        cnn_run = st.button(f"▶ Run {selected} Scan", key="cnn_run")
-
-        cnn_progress = st.empty()
-        cnn_live     = st.empty()
-        cnn_results  = st.container()
-
-        if cnn_run:
-            dets, hmap, ms, nw = sliding_window_detect(
-                right_img, backbone.get_features, head,
-                stride, conf_thresh, nms_iou,
-                progress_placeholder=cnn_progress,
-                live_image_placeholder=cnn_live,
-            )
-
-            # 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:
-                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)
-            cnn_progress.empty()
-
-            with cnn_results:
-                cm1, cm2, cm3, cm4 = st.columns(4)
-                cm1.metric("Detections", len(dets))
-                cm2.metric("Windows", nw)
-                cm3.metric("Total Time", f"{ms:.0f} ms")
-                cm4.metric("Per Window", f"{ms/max(nw,1):.2f} ms")
-
-                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)
-                    st.image(cv2.cvtColor(blend, cv2.COLOR_BGR2RGB),
-                             caption=f"{selected} — Confidence Heatmap",
-                             use_container_width=True)
-
-                if dets:
-                    import pandas as pd
-                    df = pd.DataFrame(dets, columns=["x1","y1","x2","y2","label","conf"])
-                    st.dataframe(df, use_container_width=True, hide_index=True)
-
-            st.session_state["cnn_dets"] = dets
-            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 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 len(methods) >= 2:
-    st.divider()
-    st.subheader("📊 Side-by-Side Comparison")
-
-    import pandas as pd
-    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 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=legend, use_container_width=True)

pages/7_Evaluation.py

@@ -1,295 +0,0 @@
-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 (results, n_missed, matched_gt_indices).
-    results = list of (det, matched_gt_label_or_None, iou) sorted by confidence.
-    matched_gt_indices = set of GT indices that were matched.
-    """
-    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), 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, matched_gt_indices = 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
-    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.")

pages/8_Stereo_Geometry.py

@@ -1,353 +0,0 @@
-import streamlit as st
-import cv2
-import numpy as np
-import re
-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__))))
-
-st.set_page_config(page_title="Stereo Geometry", layout="wide")
-st.title("📐 Stereo Geometry: Distance Estimation")
-
-# ---------------------------------------------------------------------------
-# Guard
-# ---------------------------------------------------------------------------
-if "pipeline_data" not in st.session_state or "left" not in st.session_state.get("pipeline_data", {}):
-    st.error("Complete **Data Lab** first.")
-    st.stop()
-
-assets    = st.session_state["pipeline_data"]
-img_l     = assets["left"]
-img_r     = assets["right"]
-gt_left   = assets.get("gt_left")       # float32 disparity map from PFM
-gt_right  = assets.get("gt_right")
-conf_raw  = assets.get("conf_raw", "")
-crop_bbox = assets.get("crop_bbox")      # (x0, y0, x1, y1) on LEFT image
-
-rce_dets = st.session_state.get("rce_dets", [])
-cnn_dets = st.session_state.get("cnn_dets", [])
-
-
-# ===================================================================
-#  Parse Middlebury-style camera config
-# ===================================================================
-def parse_config(text: str) -> dict:
-    """
-    Parse a Middlebury .txt / .conf calibration file.
-    Expected keys: cam0, cam1, doffs, baseline, width, height, ndisp, vmin, vmax
-    cam0 / cam1 are 3×3 matrices in bracket notation: [f 0 cx; 0 f cy; 0 0 1]
-    """
-    params = {}
-    if not text or not text.strip():
-        return params
-    for line in text.strip().splitlines():
-        line = line.strip()
-        if "=" not in line:
-            continue
-        key, val = line.split("=", 1)
-        key = key.strip()
-        val = val.strip()
-        if "[" in val:
-            nums = list(map(float, re.findall(r"[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?", val)))
-            params[key] = np.array(nums).reshape(3, 3) if len(nums) == 9 else nums
-        else:
-            try:
-                params[key] = float(val)
-            except ValueError:
-                params[key] = val
-    return params
-
-
-calib = parse_config(conf_raw)
-
-# Extract intrinsics
-cam0 = calib.get("cam0")
-focal    = float(cam0[0, 0]) if isinstance(cam0, np.ndarray) and cam0.shape == (3, 3) else 0.0
-doffs    = float(calib.get("doffs", 0.0))
-baseline = float(calib.get("baseline", 1.0))
-ndisp    = int(calib.get("ndisp", 128))
-
-if focal <= 0:
-    st.error("❌ Focal length is **0** — the camera config is missing or malformed. "
-            "Depth estimation cannot proceed. Return to **Data Lab** and upload a valid "
-            "Middlebury camera config.")
-    st.stop()
-
-if focal > 10000:
-    st.error(f"❌ Focal length ({focal:.0f} px) is suspiciously large. "
-             "Check your camera config file.")
-    st.stop()
-
-if baseline <= 0 or baseline > 1000:
-    st.error(f"❌ Invalid baseline ({baseline:.1f}). Expected 1–1000 mm.")
-    st.stop()
-
-st.subheader("Camera Calibration")
-cc1, cc2, cc3, cc4 = st.columns(4)
-cc1.metric("Focal Length (px)", f"{focal:.1f}")
-cc2.metric("Baseline (mm)", f"{baseline:.1f}")
-cc3.metric("Doffs (px)", f"{doffs:.2f}")
-cc4.metric("ndisp", str(ndisp))
-
-with st.expander("Full Calibration"):
-    st.json({k: v.tolist() if isinstance(v, np.ndarray) else v for k, v in calib.items()})
-
-st.divider()
-
-
-# ===================================================================
-#  Image-size validation
-# ===================================================================
-if img_l.shape[:2] != img_r.shape[:2]:
-    st.error(f"Left ({img_l.shape[1]}×{img_l.shape[0]}) and right "
-             f"({img_r.shape[1]}×{img_r.shape[0]}) images must be the same size.")
-    st.stop()
-
-
-# ===================================================================
-#  Step 1 — Compute Disparity Map
-# ===================================================================
-st.subheader("Step 1: Disparity Map (StereoSGBM)")
-
-sc1, sc2, sc3 = st.columns(3)
-block_size  = sc1.slider("Block Size", 3, 21, 5, step=2)
-p1_mult     = sc2.slider("P1 multiplier", 1, 32, 8)
-p2_mult     = sc3.slider("P2 multiplier", 1, 128, 32)
-
-
-@st.cache_data
-def compute_disparity(_left, _right, ndisp, block_size, p1m, p2m):
-    """StereoSGBM disparity.  _left/_right are un-hashed (numpy arrays)."""
-    gray_l = cv2.cvtColor(_left,  cv2.COLOR_BGR2GRAY)
-    gray_r = cv2.cvtColor(_right, cv2.COLOR_BGR2GRAY)
-
-    nd = max(16, (ndisp // 16) * 16)
-    sgbm = cv2.StereoSGBM_create(
-        minDisparity=0,
-        numDisparities=nd,
-        blockSize=block_size,
-        P1=p1m * 1 * block_size ** 2,
-        P2=p2m * 1 * block_size ** 2,
-        disp12MaxDiff=1,
-        uniquenessRatio=10,
-        speckleWindowSize=100,
-        speckleRange=32,
-        mode=cv2.STEREO_SGBM_MODE_SGBM_3WAY,
-    )
-    return sgbm.compute(gray_l, gray_r).astype(np.float32) / 16.0
-
-
-with st.spinner("Computing disparity…"):
-    try:
-        disp = compute_disparity(img_l, img_r, ndisp, block_size, p1_mult, p2_mult)
-    except cv2.error as e:
-        st.error(f"StereoSGBM failed: {e}")
-        st.stop()
-
-# Visualize disparity
-disp_vis = np.clip(disp, 0, None)
-disp_max = disp_vis.max() if disp_vis.max() > 0 else 1.0
-disp_norm = (disp_vis / disp_max * 255).astype(np.uint8)
-disp_color = cv2.applyColorMap(disp_norm, cv2.COLORMAP_INFERNO)
-
-dc1, dc2 = st.columns(2)
-dc1.image(cv2.cvtColor(img_l, cv2.COLOR_BGR2RGB), caption="Left Image", use_container_width=True)
-dc2.image(cv2.cvtColor(disp_color, cv2.COLOR_BGR2RGB), caption="Disparity Map (SGBM)", use_container_width=True)
-
-
-# ===================================================================
-#  Step 2 — Depth Map from Disparity
-# ===================================================================
-st.divider()
-st.subheader("Step 2: Depth Map from Disparity")
-
-st.latex(r"Z = \frac{f \times B}{d + d_{\text{offs}}}")
-st.caption("Z = depth (mm), f = focal length (px), B = baseline (mm), d = disparity (px), d_offs = optical center offset (px)")
-
-# Compute depth from disparity
-valid = (disp + doffs) > 0
-depth_map = np.zeros_like(disp)
-if focal > 0:
-    depth_map[valid] = (focal * baseline) / (disp[valid] + doffs)
-
-# Visualize
-depth_vis = depth_map.copy()
-finite = depth_vis[depth_vis > 0]
-if len(finite) > 0:
-    clip_max = np.percentile(finite, 98)
-    depth_vis = np.clip(depth_vis, 0, clip_max)
-    depth_norm = (depth_vis / clip_max * 255).astype(np.uint8)
-else:
-    depth_norm = np.zeros_like(depth_map, dtype=np.uint8)
-
-depth_color = cv2.applyColorMap(depth_norm, cv2.COLORMAP_TURBO)
-
-zc1, zc2 = st.columns(2)
-zc1.image(cv2.cvtColor(depth_color, cv2.COLOR_BGR2RGB),
-          caption="Estimated Depth (SGBM)", use_container_width=True)
-
-# Ground truth comparison
-if gt_left is not None:
-    gt_vis = gt_left.copy()
-    gt_finite = gt_vis[np.isfinite(gt_vis) & (gt_vis > 0)]
-    if len(gt_finite) > 0:
-        gt_clip = np.percentile(gt_finite, 98)
-        gt_vis = np.clip(np.nan_to_num(gt_vis, nan=0), 0, gt_clip)
-        gt_norm = (gt_vis / gt_clip * 255).astype(np.uint8)
-    else:
-        gt_norm = np.zeros_like(gt_vis, dtype=np.uint8)
-    gt_color = cv2.applyColorMap(gt_norm, cv2.COLORMAP_TURBO)
-    zc2.image(cv2.cvtColor(gt_color, cv2.COLOR_BGR2RGB),
-              caption="Ground Truth Disparity (from PFM)", use_container_width=True)
-
-
-# ===================================================================
-#  Step 3 — Error Map (SGBM vs Ground Truth)
-# ===================================================================
-if gt_left is not None:
-    st.divider()
-    st.subheader("Step 3: Error Analysis (SGBM vs Ground Truth)")
-
-    gt_disp = gt_left   # Middlebury standard: PFM = disparity map
-
-    # Ensure GT and SGBM disparity have the same shape
-    if gt_disp.shape[:2] != disp.shape[:2]:
-        st.warning(
-            f"Ground truth shape ({gt_disp.shape[1]}×{gt_disp.shape[0]}) differs from "
-            f"disparity shape ({disp.shape[1]}×{disp.shape[0]}). Resizing GT to match."
-        )
-        gt_disp = cv2.resize(gt_disp, (disp.shape[1], disp.shape[0]),
-                             interpolation=cv2.INTER_NEAREST)
-
-    gt_valid = np.isfinite(gt_disp) & (gt_disp > 0)
-    both_valid = valid & gt_valid
-
-    if both_valid.any():
-        # Disparity error
-        disp_err = np.abs(disp - gt_disp)
-        disp_err[~both_valid] = 0
-
-        # Stats
-        err_vals = disp_err[both_valid]
-        mae  = float(np.mean(err_vals))
-        rmse = float(np.sqrt(np.mean(err_vals ** 2)))
-        bad_2 = float(np.mean(err_vals > 2.0)) * 100
-
-        em1, em2, em3 = st.columns(3)
-        em1.metric("MAE (px)", f"{mae:.2f}")
-        em2.metric("RMSE (px)", f"{rmse:.2f}")
-        em3.metric("Bad-2.0 (%)", f"{bad_2:.1f}%")
-
-        # Error heatmap
-        err_clip = np.clip(disp_err, 0, 10)
-        err_norm = (err_clip / 10 * 255).astype(np.uint8)
-        err_color = cv2.applyColorMap(err_norm, cv2.COLORMAP_HOT)
-        st.image(cv2.cvtColor(err_color, cv2.COLOR_BGR2RGB),
-                 caption="Disparity Error Map (red = high error, clipped at 10 px)",
-                 use_container_width=True)
-
-        # Histogram
-        fig = go.Figure(data=[go.Histogram(x=err_vals, nbinsx=50,
-                                           marker_color="#ff6361")])
-        fig.update_layout(title="Disparity Error Distribution",
-                          xaxis_title="Absolute Error (px)",
-                          yaxis_title="Pixel Count",
-                          template="plotly_dark", height=300)
-        st.plotly_chart(fig, use_container_width=True)
-    else:
-        st.warning("No overlapping valid pixels between SGBM disparity and ground truth.")
-
-
-# ===================================================================
-#  Step 4 — Object Distance from Detections
-# ===================================================================
-st.divider()
-st.subheader("Step 4: Object Distance Estimation")
-
-all_dets = []
-all_dets.extend(("RCE", *d) for d in rce_dets)
-all_dets.extend(("CNN", *d) for d in cnn_dets)
-
-if not all_dets and crop_bbox is not None:
-    st.info("No detections from the Real-Time Detection page. Using the **crop bounding box** as a fallback.")
-    x0, y0, x1, y1 = crop_bbox
-    all_dets.append(("Crop", x0, y0, x1, y1, "object", 1.0))
-elif not all_dets:
-    st.warning("No detections found. Run **Real-Time Detection** first, or define a crop in **Data Lab**.")
-    st.stop()
-
-if focal <= 0:
-    st.warning("Focal length is 0 — cannot compute depth. Upload a valid config in **Data Lab**.")
-    st.stop()
-
-rows = []
-det_overlay = img_l.copy()
-
-for source, dx1, dy1, dx2, dy2, lbl, conf in all_dets:
-    dx1, dy1, dx2, dy2 = int(dx1), int(dy1), int(dx2), int(dy2)
-
-    # Clamp to image bounds
-    H, W = depth_map.shape[:2]
-    dx1c = max(0, min(dx1, W - 1))
-    dy1c = max(0, min(dy1, H - 1))
-    dx2c = max(0, min(dx2, W))
-    dy2c = max(0, min(dy2, H))
-
-    roi_depth = depth_map[dy1c:dy2c, dx1c:dx2c]
-    roi_disp  = disp[dy1c:dy2c, dx1c:dx2c]
-    roi_valid = roi_depth[roi_depth > 0]
-
-    if len(roi_valid) > 0:
-        med_depth  = float(np.median(roi_valid))
-        mean_depth = float(np.mean(roi_valid))
-        med_disp   = float(np.median(roi_disp[roi_disp > 0])) if (roi_disp > 0).any() else 0
-    else:
-        med_depth = mean_depth = med_disp = 0.0
-
-    # Ground truth depth at this region
-    gt_depth_val = 0.0
-    if gt_left is not None:
-        gt_roi = gt_left[dy1c:dy2c, dx1c:dx2c]
-        gt_roi_valid = gt_roi[np.isfinite(gt_roi) & (gt_roi > 0)]
-        if len(gt_roi_valid) > 0:
-            gt_med_disp  = float(np.median(gt_roi_valid))
-            gt_depth_val = (focal * baseline) / (gt_med_disp + doffs) if (gt_med_disp + doffs) > 0 else 0
-
-    error_mm = abs(med_depth - gt_depth_val) if gt_depth_val > 0 else float("nan")
-
-    rows.append({
-        "Source":        source,
-        "Box":           f"({dx1},{dy1})→({dx2},{dy2})",
-        "Confidence":    f"{conf:.1%}" if isinstance(conf, float) else str(conf),
-        "Med Disparity": f"{med_disp:.1f} px",
-        "Med Depth":     f"{med_depth:.0f} mm",
-        "Mean Depth":    f"{mean_depth:.0f} mm",
-        "GT Depth":      f"{gt_depth_val:.0f} mm" if gt_depth_val > 0 else "N/A",
-        "Error":         f"{error_mm:.0f} mm" if not np.isnan(error_mm) else "N/A",
-    })
-
-    # Draw on overlay
-    color = (0, 255, 0) if "RCE" in source else (0, 0, 255) if "CNN" in source else (255, 255, 0)
-    cv2.rectangle(det_overlay, (dx1c, dy1c), (dx2c, dy2c), color, 2)
-    depth_str = f"{med_depth / 1000:.2f}m" if med_depth > 0 else "?"
-    cv2.putText(det_overlay, f"{source} {depth_str}",
-                (dx1c, max(dy1c - 6, 12)), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
-
-# Show overlay
-st.image(cv2.cvtColor(det_overlay, cv2.COLOR_BGR2RGB),
-         caption="Detections with Estimated Distance",
-         use_container_width=True)
-
-# Table
-st.dataframe(pd.DataFrame(rows), use_container_width=True, hide_index=True)
-
-# Primary detection summary
-if rows:
-    best = rows[0]
-    st.divider()
-    st.subheader("🎯 Primary Detection — Distance")
-    bc1, bc2, bc3 = st.columns(3)
-    bc1.metric("Estimated Depth", best["Med Depth"])
-    bc2.metric("Ground Truth", best["GT Depth"])
-    bc3.metric("Absolute Error", best["Error"])

tabs/generalisation/data_lab.py

@@ -0,0 +1,269 @@
+"""Generalisation Data Lab — Stage 1 of the Generalisation pipeline."""
+
+import streamlit as st
+import cv2
+import numpy as np
+import os
+
+from utils.middlebury_loader import (
+    DEFAULT_MIDDLEBURY_ROOT, get_scene_groups, load_single_view,
+    read_pfm_bytes,
+)
+
+
+# ------------------------------------------------------------------
+# Helpers (shared with stereo data lab)
+# ------------------------------------------------------------------
+
+def _augment(img, brightness, contrast, rotation,
+             flip_h, flip_v, noise, blur, shift_x, shift_y):
+    out = img.astype(np.float32)
+    out = np.clip(contrast * out + brightness, 0, 255)
+    if noise > 0:
+        out = np.clip(out + np.random.normal(0, noise, out.shape), 0, 255)
+    out = out.astype(np.uint8)
+    k = blur * 2 + 1
+    if k > 1:
+        out = cv2.GaussianBlur(out, (k, k), 0)
+    if rotation != 0:
+        h, w = out.shape[:2]
+        M = cv2.getRotationMatrix2D((w / 2, h / 2), rotation, 1.0)
+        out = cv2.warpAffine(out, M, (w, h), borderMode=cv2.BORDER_REFLECT)
+    if shift_x != 0 or shift_y != 0:
+        h, w = out.shape[:2]
+        M = np.float32([[1, 0, shift_x], [0, 1, shift_y]])
+        out = cv2.warpAffine(out, M, (w, h), borderMode=cv2.BORDER_REFLECT)
+    if flip_h:
+        out = cv2.flip(out, 1)
+    if flip_v:
+        out = cv2.flip(out, 0)
+    return out
+
+
+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)]
+MAX_UPLOAD_BYTES = 50 * 1024 * 1024
+
+
+def render():
+    st.header("🧪 Data Lab — Generalisation")
+    st.info("**How this works:** Train on one image, test on a completely "
+            "different image of the same object. No stereo geometry — "
+            "pure recognition generalisation.")
+
+    source = st.radio("Data source",
+                      ["📦 Middlebury Multi-View", "📁 Upload your own files"],
+                      horizontal=True, key="gen_source")
+
+    # ===================================================================
+    #  Middlebury multi-view
+    # ===================================================================
+    if source == "📦 Middlebury Multi-View":
+        groups = get_scene_groups()
+        if not groups:
+            st.error("No valid Middlebury scenes found in ./data/middlebury/")
+            return
+
+        group_name = st.selectbox("Scene group", list(groups.keys()), key="gen_group")
+        variants = groups[group_name]
+
+        gc1, gc2 = st.columns(2)
+        train_scene = gc1.selectbox("Training scene", variants, key="gen_train_scene")
+        available_test = [v for v in variants if v != train_scene]
+        if not available_test:
+            st.error("Need at least 2 variants in a group.")
+            return
+        test_scene = gc2.selectbox("Test scene", available_test, key="gen_test_scene")
+
+        train_path = os.path.join(DEFAULT_MIDDLEBURY_ROOT, train_scene)
+        test_path  = os.path.join(DEFAULT_MIDDLEBURY_ROOT, test_scene)
+
+        img_train = load_single_view(train_path)
+        img_test  = load_single_view(test_path)
+
+        st.markdown("*Both images show the same scene type captured under different "
+                    "conditions. The model trains on one variant and must recognise "
+                    "the same object class in the other — testing genuine appearance "
+                    "generalisation.*")
+
+        c1, c2 = st.columns(2)
+        c1.image(cv2.cvtColor(img_train, cv2.COLOR_BGR2RGB),
+                 caption=f"🟦 TRAIN IMAGE ({train_scene})", use_container_width=True)
+        c2.image(cv2.cvtColor(img_test, cv2.COLOR_BGR2RGB),
+                 caption=f"🟥 TEST IMAGE ({test_scene})", use_container_width=True)
+
+        scene_group = group_name
+
+    # ===================================================================
+    #  Custom upload
+    # ===================================================================
+    else:
+        uc1, uc2 = st.columns(2)
+        with uc1:
+            up_train = st.file_uploader("Train Image", type=["png","jpg","jpeg"],
+                                        key="gen_up_train")
+        with uc2:
+            up_test = st.file_uploader("Test Image", type=["png","jpg","jpeg"],
+                                       key="gen_up_test")
+
+        if not (up_train and up_test):
+            st.info("Upload a train and test image to proceed.")
+            return
+
+        if up_train.size > MAX_UPLOAD_BYTES or up_test.size > MAX_UPLOAD_BYTES:
+            st.error("Image too large (max 50 MB).")
+            return
+
+        img_train = cv2.imdecode(np.frombuffer(up_train.read(), np.uint8), cv2.IMREAD_COLOR); up_train.seek(0)
+        img_test  = cv2.imdecode(np.frombuffer(up_test.read(), np.uint8), cv2.IMREAD_COLOR); up_test.seek(0)
+
+        c1, c2 = st.columns(2)
+        c1.image(cv2.cvtColor(img_train, cv2.COLOR_BGR2RGB),
+                 caption="🟦 TRAIN IMAGE", use_container_width=True)
+        c2.image(cv2.cvtColor(img_test, cv2.COLOR_BGR2RGB),
+                 caption="🟥 TEST IMAGE", use_container_width=True)
+
+        train_scene = "custom_train"
+        test_scene  = "custom_test"
+        scene_group = "custom"
+
+    # ===================================================================
+    #  ROI Definition  (on TRAIN image)
+    # ===================================================================
+    st.divider()
+    st.subheader("Step 2: Crop Region(s) of Interest")
+    st.write("Define bounding boxes on the **TRAIN image**.")
+
+    H, W = img_train.shape[:2]
+
+    if "gen_rois" not in st.session_state:
+        st.session_state["gen_rois"] = [
+            {"label": "object", "x0": 0, "y0": 0,
+             "x1": min(W, 100), "y1": min(H, 100)}
+        ]
+
+    def _add_roi():
+        if len(st.session_state["gen_rois"]) >= 20:
+            return
+        st.session_state["gen_rois"].append(
+            {"label": f"object_{len(st.session_state['gen_rois'])+1}",
+             "x0": 0, "y0": 0,
+             "x1": min(W, 100), "y1": min(H, 100)})
+
+    def _remove_roi(idx):
+        if len(st.session_state["gen_rois"]) > 1:
+            st.session_state["gen_rois"].pop(idx)
+
+    for i, roi in enumerate(st.session_state["gen_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"gen_roi_lbl_{i}")
+            if len(st.session_state["gen_rois"]) > 1:
+                hc3.button("✕", key=f"gen_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"gen_roi_x0_{i}"))
+            roi["y0"] = int(cr2.number_input("Y start", 0, H-2, int(roi["y0"]),
+                                              step=1, key=f"gen_roi_y0_{i}"))
+            roi["x1"] = int(cr3.number_input("X end", roi["x0"]+1, W,
+                                              min(W, int(roi["x1"])),
+                                              step=1, key=f"gen_roi_x1_{i}"))
+            roi["y1"] = int(cr4.number_input("Y end", roi["y0"]+1, H,
+                                              min(H, int(roi["y1"])),
+                                              step=1, key=f"gen_roi_y1_{i}"))
+
+    st.button("➕ Add Another ROI", on_click=_add_roi,
+              disabled=len(st.session_state["gen_rois"]) >= 20,
+              key="gen_add_roi")
+
+    overlay = img_train.copy()
+    crops = []
+    for i, roi in enumerate(st.session_state["gen_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_train[y0:y1, x0:x1].copy())
+
+    ov1, ov2 = st.columns([3, 2])
+    ov1.image(cv2.cvtColor(overlay, cv2.COLOR_BGR2RGB),
+              caption="TRAIN image — ROIs highlighted", use_container_width=True)
+    with ov2:
+        for i, (c, roi) in enumerate(zip(crops, st.session_state["gen_rois"])):
+            st.image(cv2.cvtColor(c, cv2.COLOR_BGR2RGB),
+                     caption=f"{roi['label']} ({c.shape[1]}×{c.shape[0]})", width=160)
+
+    crop_bgr = crops[0]
+    x0 = st.session_state["gen_rois"][0]["x0"]
+    y0 = st.session_state["gen_rois"][0]["y0"]
+    x1 = st.session_state["gen_rois"][0]["x1"]
+    y1 = st.session_state["gen_rois"][0]["y1"]
+
+    # ===================================================================
+    #  Augmentation
+    # ===================================================================
+    st.divider()
+    st.subheader("Step 3: Data Augmentation")
+    ac1, ac2 = st.columns(2)
+    with ac1:
+        brightness = st.slider("Brightness offset", -100, 100, 0, key="gen_bright")
+        contrast   = st.slider("Contrast scale", 0.5, 3.0, 1.0, 0.05, key="gen_contrast")
+        rotation   = st.slider("Rotation (°)", -180, 180, 0, key="gen_rot")
+        noise      = st.slider("Gaussian noise σ", 0, 50, 0, key="gen_noise")
+    with ac2:
+        blur    = st.slider("Blur kernel (0=off)", 0, 10, 0, key="gen_blur")
+        shift_x = st.slider("Shift X (px)", -100, 100, 0, key="gen_sx")
+        shift_y = st.slider("Shift Y (px)", -100, 100, 0, key="gen_sy")
+        flip_h  = st.checkbox("Flip Horizontal", key="gen_fh")
+        flip_v  = st.checkbox("Flip Vertical", key="gen_fv")
+
+    aug = _augment(crop_bgr, brightness, contrast, rotation,
+                   flip_h, flip_v, noise, blur, shift_x, shift_y)
+    all_augs = [_augment(c, brightness, contrast, rotation,
+                         flip_h, flip_v, noise, blur, shift_x, shift_y)
+                for c in crops]
+
+    ag1, ag2 = st.columns(2)
+    ag1.image(cv2.cvtColor(crop_bgr, cv2.COLOR_BGR2RGB),
+              caption="Original Crop (ROI 1)", use_container_width=True)
+    ag2.image(cv2.cvtColor(aug, cv2.COLOR_BGR2RGB),
+              caption="Augmented Crop (ROI 1)", use_container_width=True)
+
+    # ===================================================================
+    #  Lock & Store
+    # ===================================================================
+    st.divider()
+    if st.button("🚀 Lock Data & Proceed", key="gen_lock"):
+        rois_data = []
+        for i, roi in enumerate(st.session_state["gen_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["gen_pipeline"] = {
+            "train_image":  img_train,
+            "test_image":   img_test,
+            "roi":          {"x": x0, "y": y0, "w": x1 - x0, "h": y1 - y0,
+                            "label": st.session_state["gen_rois"][0]["label"]},
+            "crop":         crop_bgr,
+            "crop_aug":     aug,
+            "crop_bbox":    (x0, y0, x1, y1),
+            "rois":         rois_data,
+            "source":       "middlebury" if source == "📦 Middlebury Multi-View" else "custom",
+            "scene_group":  scene_group if "scene_group" in dir() else "",
+            "train_scene":  train_scene if "train_scene" in dir() else "",
+            "test_scene":   test_scene if "test_scene" in dir() else "",
+        }
+        st.success(f"✅ Data locked with **{len(rois_data)} ROI(s)**! "
+                   f"Proceed to Feature Lab.")

tabs/generalisation/detection.py

@@ -0,0 +1,388 @@
+"""Generalisation Detection — Stage 5 of the Generalisation pipeline.
+
+CRITICAL: Detection runs on the TEST image (different scene variant).
+          Training was done on the TRAIN image.
+          This enforces the data-leakage fix.
+"""
+
+import streamlit as st
+import cv2
+import numpy as np
+import time
+import plotly.graph_objects as go
+
+from src.detectors.rce.features import REGISTRY
+from src.models import BACKBONES, RecognitionHead
+from src.utils import build_rce_vector
+from src.localization import nms as _nms
+
+
+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)]
+
+
+def sliding_window_detect(image, feature_fn, head, win_h, win_w,
+                           stride, conf_thresh, nms_iou,
+                           progress_placeholder=None,
+                           live_image_placeholder=None):
+    H, W = image.shape[:2]
+    heatmap = np.zeros((H, W), dtype=np.float32)
+    detections = []
+    t0 = time.perf_counter()
+
+    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)
+    if n_total == 0:
+        return [], heatmap, 0.0, 0
+
+    for idx, (x, y) in enumerate(positions):
+        patch = image[y:y+win_h, x:x+win_w]
+        feats = feature_fn(patch)
+        label, conf = head.predict(feats)
+
+        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:
+                detections.append((x, y, x+win_w, y+win_h, label, conf))
+
+        if live_image_placeholder is not None and (idx % 5 == 0 or idx == n_total - 1):
+            vis = image.copy()
+            cv2.rectangle(vis, (x, y), (x+win_w, y+win_h), (255, 255, 0), 1)
+            for dx, dy, dx2, dy2, dl, dc in detections:
+                cv2.rectangle(vis, (dx, dy), (dx2, dy2), (0, 255, 0), 2)
+                cv2.putText(vis, f"{dc:.0%}", (dx, dy - 4),
+                            cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 255, 0), 1)
+            live_image_placeholder.image(
+                cv2.cvtColor(vis, cv2.COLOR_BGR2RGB),
+                caption=f"Scanning… {idx+1}/{n_total}",
+                use_container_width=True)
+
+        if progress_placeholder is not None:
+            progress_placeholder.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)
+    return detections, heatmap, total_ms, n_total
+
+
+def render():
+    st.title("🎯 Real-Time Detection")
+
+    pipe = st.session_state.get("gen_pipeline")
+    if not pipe or "crop" not in pipe:
+        st.error("Complete **Data Lab** first (upload assets & define a crop).")
+        st.stop()
+
+    # CRITICAL: detect on TEST image, not TRAIN image
+    test_img     = pipe["test_image"]
+    crop         = pipe["crop"]
+    crop_aug     = pipe.get("crop_aug", crop)
+    bbox         = pipe.get("crop_bbox", (0, 0, crop.shape[1], crop.shape[0]))
+    rois         = pipe.get("rois", [{"label": "object", "bbox": bbox,
+                                       "crop": crop, "crop_aug": crop_aug}])
+    active_mods  = pipe.get("active_modules", {k: True for k in REGISTRY})
+
+    x0, y0, x1, y1 = bbox
+    win_h, win_w = y1 - y0, x1 - x0
+
+    if win_h <= 0 or win_w <= 0:
+        st.error("Invalid window size from crop bbox.")
+        st.stop()
+
+    rce_head = pipe.get("rce_head")
+    has_any_cnn = any(f"cnn_head_{n}" in pipe for n in BACKBONES)
+    has_orb = pipe.get("orb_refs") is not None
+
+    if rce_head is None and not has_any_cnn and not has_orb:
+        st.warning("No trained heads found. Go to **Model Tuning** first.")
+        st.stop()
+
+    def rce_feature_fn(patch_bgr):
+        return build_rce_vector(patch_bgr, active_mods)
+
+    # Controls
+    st.subheader("Sliding Window Parameters")
+    p1, p2, p3 = st.columns(3)
+    stride = p1.slider("Stride (px)", 4, max(win_w // 2, 4),
+                        max(win_w // 4, 4), step=2, key="gen_det_stride")
+    conf_thresh = p2.slider("Confidence Threshold", 0.5, 1.0, 0.7, 0.05,
+                             key="gen_det_conf")
+    nms_iou = p3.slider("NMS IoU Threshold", 0.1, 0.9, 0.3, 0.05,
+                         key="gen_det_nms")
+
+    st.caption(f"Window size: **{win_w}×{win_h} px**  |  "
+               f"Test image: **{test_img.shape[1]}×{test_img.shape[0]} px**  |  "
+               f"≈ {((test_img.shape[0]-win_h)//stride + 1) * ((test_img.shape[1]-win_w)//stride + 1)} windows")
+    st.divider()
+
+    col_rce, col_cnn, col_orb = st.columns(3)
+
+    # -------------------------------------------------------------------
+    # RCE Detection
+    # -------------------------------------------------------------------
+    with col_rce:
+        st.header("🧬 RCE Detection")
+        if rce_head is None:
+            st.info("No RCE head trained.")
+        else:
+            st.caption(f"Modules: {', '.join(REGISTRY[k]['label'] for k in active_mods if active_mods[k])}")
+            rce_run = st.button("▶ Run RCE Scan", key="gen_rce_run")
+            rce_progress = st.empty()
+            rce_live = st.empty()
+            rce_results = st.container()
+
+            if rce_run:
+                dets, hmap, ms, nw = sliding_window_detect(
+                    test_img, rce_feature_fn, rce_head, win_h, win_w,
+                    stride, conf_thresh, nms_iou,
+                    progress_placeholder=rce_progress,
+                    live_image_placeholder=rce_live)
+
+                final = test_img.copy()
+                class_labels = sorted(set(d[4] for d in dets)) if dets else []
+                for x1d, y1d, x2d, y2d, lbl, cf in dets:
+                    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)
+                rce_progress.empty()
+
+                with rce_results:
+                    rm1, rm2, rm3, rm4 = st.columns(4)
+                    rm1.metric("Detections", len(dets))
+                    rm2.metric("Windows", nw)
+                    rm3.metric("Total Time", f"{ms:.0f} ms")
+                    rm4.metric("Per Window", f"{ms/max(nw,1):.2f} ms")
+
+                    if hmap.max() > 0:
+                        hmap_color = cv2.applyColorMap(
+                            (hmap / hmap.max() * 255).astype(np.uint8),
+                            cv2.COLORMAP_JET)
+                        blend = cv2.addWeighted(test_img, 0.5, hmap_color, 0.5, 0)
+                        st.image(cv2.cvtColor(blend, cv2.COLOR_BGR2RGB),
+                                 caption="RCE — Confidence Heatmap",
+                                 use_container_width=True)
+
+                    if dets:
+                        import pandas as pd
+                        df = pd.DataFrame(dets, columns=["x1","y1","x2","y2","label","conf"])
+                        st.dataframe(df, use_container_width=True, hide_index=True)
+
+                pipe["rce_dets"] = dets
+                pipe["rce_det_ms"] = ms
+                st.session_state["gen_pipeline"] = pipe
+
+    # -------------------------------------------------------------------
+    # CNN Detection
+    # -------------------------------------------------------------------
+    with col_cnn:
+        st.header("🧠 CNN Detection")
+        trained_cnns = [n for n in BACKBONES if f"cnn_head_{n}" in pipe]
+        if not trained_cnns:
+            st.info("No CNN head trained.")
+        else:
+            selected = st.selectbox("Select Model", trained_cnns,
+                                    key="gen_det_cnn_sel")
+            bmeta    = BACKBONES[selected]
+            backbone = bmeta["loader"]()
+            head     = pipe[f"cnn_head_{selected}"]
+
+            st.caption(f"Backbone: **{selected}** ({bmeta['dim']}D)")
+            cnn_run = st.button(f"▶ Run {selected} Scan", key="gen_cnn_run")
+            cnn_progress = st.empty()
+            cnn_live = st.empty()
+            cnn_results = st.container()
+
+            if cnn_run:
+                dets, hmap, ms, nw = sliding_window_detect(
+                    test_img, backbone.get_features, head, win_h, win_w,
+                    stride, conf_thresh, nms_iou,
+                    progress_placeholder=cnn_progress,
+                    live_image_placeholder=cnn_live)
+
+                final = test_img.copy()
+                class_labels = sorted(set(d[4] for d in dets)) if dets else []
+                for x1d, y1d, x2d, y2d, lbl, cf in dets:
+                    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)
+                cnn_progress.empty()
+
+                with cnn_results:
+                    cm1, cm2, cm3, cm4 = st.columns(4)
+                    cm1.metric("Detections", len(dets))
+                    cm2.metric("Windows", nw)
+                    cm3.metric("Total Time", f"{ms:.0f} ms")
+                    cm4.metric("Per Window", f"{ms/max(nw,1):.2f} ms")
+
+                    if hmap.max() > 0:
+                        hmap_color = cv2.applyColorMap(
+                            (hmap / hmap.max() * 255).astype(np.uint8),
+                            cv2.COLORMAP_JET)
+                        blend = cv2.addWeighted(test_img, 0.5, hmap_color, 0.5, 0)
+                        st.image(cv2.cvtColor(blend, cv2.COLOR_BGR2RGB),
+                                 caption=f"{selected} — Confidence Heatmap",
+                                 use_container_width=True)
+
+                    if dets:
+                        import pandas as pd
+                        df = pd.DataFrame(dets, columns=["x1","y1","x2","y2","label","conf"])
+                        st.dataframe(df, use_container_width=True, hide_index=True)
+
+                pipe["cnn_dets"] = dets
+                pipe["cnn_det_ms"] = ms
+                st.session_state["gen_pipeline"] = pipe
+
+    # -------------------------------------------------------------------
+    # ORB Detection
+    # -------------------------------------------------------------------
+    with col_orb:
+        st.header("🏛️ ORB Detection")
+        if not has_orb:
+            st.info("No ORB reference trained.")
+        else:
+            orb_det  = pipe["orb_detector"]
+            orb_refs = pipe["orb_refs"]
+            dt_thresh = pipe.get("orb_dist_thresh", 70)
+            min_m     = pipe.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="gen_orb_run")
+            orb_progress = st.empty()
+            orb_live = st.empty()
+            orb_results = st.container()
+
+            if orb_run:
+                H, W = test_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 = test_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 = test_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(test_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)
+
+                pipe["orb_dets"] = detections
+                pipe["orb_det_ms"] = total_ms
+                st.session_state["gen_pipeline"] = pipe
+
+    # ===================================================================
+    # Bottom — Comparison
+    # ===================================================================
+    rce_dets = pipe.get("rce_dets")
+    cnn_dets = pipe.get("cnn_dets")
+    orb_dets = pipe.get("orb_dets")
+
+    methods = {}
+    if rce_dets is not None:
+        methods["RCE"] = (rce_dets, pipe.get("rce_det_ms", 0), (0,255,0))
+    if cnn_dets is not None:
+        methods["CNN"] = (cnn_dets, pipe.get("cnn_det_ms", 0), (0,0,255))
+    if orb_dets is not None:
+        methods["ORB"] = (orb_dets, pipe.get("orb_det_ms", 0), (255,165,0))
+
+    if len(methods) >= 2:
+        st.divider()
+        st.subheader("📊 Side-by-Side Comparison")
+        import pandas as pd
+        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 = test_img.copy()
+        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=legend, use_container_width=True)

tabs/generalisation/evaluation.py

@@ -0,0 +1,205 @@
+"""Generalisation Evaluation — Stage 6 of the Generalisation pipeline."""
+
+import streamlit as st
+import cv2
+import numpy as np
+import plotly.graph_objects as go
+import plotly.figure_factory as ff
+
+from src.models import BACKBONES
+
+
+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):
+    dets_sorted = sorted(dets, key=lambda d: d[5], reverse=True)
+    matched_gt = set()
+    results = []
+    for det in dets_sorted:
+        det_box = det[:4]
+        best_iou, best_gt_idx, best_gt_label = 0.0, -1, 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, best_gt_idx, best_gt_label = iou_val, gi, 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), matched_gt
+
+
+def compute_pr_curve(dets, gt_list, iou_thr, steps=50):
+    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):
+    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, matched_gt_indices = match_detections(dets, gt_list, iou_thr)
+    for det, gt_lbl, _ in matched:
+        pred_lbl = det[4]
+        if gt_lbl is not None:
+            pi = label_to_idx.get(pred_lbl, label_to_idx["background"])
+            gi = label_to_idx[gt_lbl]
+            matrix[pi][gi] += 1
+        else:
+            pi = label_to_idx.get(pred_lbl, label_to_idx["background"])
+            matrix[pi][label_to_idx["background"]] += 1
+    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
+
+
+def render():
+    st.title("📈 Evaluation: Confusion Matrix & PR Curves")
+
+    pipe = st.session_state.get("gen_pipeline")
+    if not pipe:
+        st.error("Complete the **Data Lab** first.")
+        st.stop()
+
+    crop     = pipe.get("crop")
+    crop_aug = pipe.get("crop_aug", crop)
+    bbox     = pipe.get("crop_bbox", (0, 0, crop.shape[1], crop.shape[0])) if crop is not None else None
+    rois     = pipe.get("rois", [{"label": "object", "bbox": bbox,
+                                   "crop": crop, "crop_aug": crop_aug}])
+
+    rce_dets = pipe.get("rce_dets")
+    cnn_dets = pipe.get("cnn_dets")
+    orb_dets = pipe.get("orb_dets")
+
+    if rce_dets is None and cnn_dets is None and orb_dets is None:
+        st.warning("Run detection first in **Real-Time Detection**.")
+        st.stop()
+
+    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 as TP",
+                                    key="gen_eval_iou")
+
+    st.subheader("Ground Truth (from Data Lab ROIs)")
+    st.caption(f"{len(gt_boxes)} ground-truth ROIs defined")
+    gt_vis = pipe["test_image"].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()
+
+    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
+
+    # 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)
+
+            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%}")
+
+    # PR 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 = float(np.trapz(precs, recs)) if recs and precs else 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)
+
+    # 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}**.")

tabs/generalisation/feature_lab.py

@@ -0,0 +1,102 @@
+"""Generalisation Feature Lab — Stage 2 of the Generalisation pipeline."""
+
+import streamlit as st
+import cv2
+import numpy as np
+import plotly.graph_objects as go
+
+from src.detectors.rce.features import REGISTRY
+from src.models import BACKBONES
+
+
+def render():
+    pipe = st.session_state.get("gen_pipeline")
+    if not pipe or "crop" not in pipe:
+        st.error("Please complete the **Data Lab** first!")
+        st.stop()
+
+    obj = pipe.get("crop_aug", pipe.get("crop"))
+    if obj is None:
+        st.error("No crop found. Go back to Data Lab and define a ROI.")
+        st.stop()
+    gray = cv2.cvtColor(obj, cv2.COLOR_BGR2GRAY)
+
+    st.title("🔬 Feature Lab: Physical Module Selection")
+
+    col_rce, col_cnn = st.columns([3, 2])
+
+    with col_rce:
+        st.header("🧬 RCE: Modular Physics Engine")
+        st.subheader("Select Active Modules")
+
+        active = {}
+        items = list(REGISTRY.items())
+        for row_start in range(0, len(items), 4):
+            row_items = items[row_start:row_start + 4]
+            m_cols = st.columns(4)
+            for col, (key, meta) in zip(m_cols, row_items):
+                active[key] = col.checkbox(meta["label"],
+                    value=(key in ("intensity", "sobel", "spectral")),
+                    key=f"gen_fl_{key}")
+
+        final_vector = []
+        viz_images = []
+        for key, meta in REGISTRY.items():
+            if active[key]:
+                vec, viz = meta["fn"](gray)
+                final_vector.extend(vec)
+                viz_images.append((meta["viz_title"], viz))
+
+        st.divider()
+        if viz_images:
+            for row_start in range(0, len(viz_images), 3):
+                row = viz_images[row_start:row_start + 3]
+                v_cols = st.columns(3)
+                for col, (title, img) in zip(v_cols, row):
+                    col.image(img, caption=title, use_container_width=True)
+        else:
+            st.warning("No modules selected — vector is empty.")
+
+        st.write(f"### Current DNA Vector Size: **{len(final_vector)}**")
+        fig_vec = go.Figure(data=[go.Bar(y=final_vector, marker_color="#00d4ff")])
+        fig_vec.update_layout(title="Active Feature Vector (RCE Input)",
+                              template="plotly_dark", height=300)
+        st.plotly_chart(fig_vec, use_container_width=True)
+
+    with col_cnn:
+        st.header("🧠 CNN: Static Architecture")
+        selected_cnn = st.selectbox("Compare against Model", list(BACKBONES.keys()),
+                                    key="gen_fl_cnn")
+        st.info("CNN features are fixed by pre-trained weights.")
+
+        with st.spinner(f"Loading {selected_cnn} and extracting activations..."):
+            try:
+                bmeta = BACKBONES[selected_cnn]
+                backbone = bmeta["loader"]()
+                layer_name = bmeta["hook_layer"]
+                act_maps = backbone.get_activation_maps(obj, n_maps=6)
+                st.caption(f"Hooked layer: `{layer_name}` — showing 6 of "
+                           f"{len(act_maps)} channels")
+                act_cols = st.columns(3)
+                for i, amap in enumerate(act_maps):
+                    act_cols[i % 3].image(amap, caption=f"Channel {i}",
+                                          use_container_width=True)
+            except Exception as e:
+                st.error(f"Could not load model: {e}")
+
+        st.divider()
+        st.markdown(f"""
+        **Analysis:**
+        - **Modularity:** RCE is **High** | CNN is **Zero**
+        - **Explainability:** RCE is **High** | CNN is **Low**
+        - **Compute Cost:** {len(final_vector)} floats | 512+ floats
+        """)
+
+    if st.button("🚀 Lock Modular Configuration", key="gen_fl_lock"):
+        if not final_vector:
+            st.error("Please select at least one module!")
+        else:
+            pipe["final_vector"] = np.array(final_vector)
+            pipe["active_modules"] = {k: v for k, v in active.items()}
+            st.session_state["gen_pipeline"] = pipe
+            st.success("Modular DNA Locked! Ready for Model Tuning.")

tabs/generalisation/localization.py

@@ -0,0 +1,302 @@
+"""Generalisation Localization Lab — Stage 4 of the Generalisation pipeline."""
+
+import streamlit as st
+import cv2
+import numpy as np
+import pandas as pd
+import plotly.graph_objects as go
+
+from src.detectors.rce.features import REGISTRY
+from src.models import BACKBONES
+from src.utils import build_rce_vector
+from src.localization import (
+    exhaustive_sliding_window,
+    image_pyramid,
+    coarse_to_fine,
+    contour_proposals,
+    template_matching,
+    STRATEGIES,
+)
+
+
+def render():
+    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."
+    )
+
+    pipe = st.session_state.get("gen_pipeline")
+    if not pipe or "crop" not in pipe:
+        st.error("Complete **Data Lab** first (upload assets & define a crop).")
+        st.stop()
+
+    test_img  = pipe["test_image"]
+    crop      = pipe["crop"]
+    crop_aug  = pipe.get("crop_aug", crop)
+    bbox      = pipe.get("crop_bbox", (0, 0, crop.shape[1], crop.shape[0]))
+    active_mods = pipe.get("active_modules", {k: True for k in REGISTRY})
+
+    x0, y0, x1, y1 = bbox
+    win_h, win_w = y1 - y0, x1 - x0
+
+    if win_h <= 0 or win_w <= 0:
+        st.error("Invalid window size from crop bbox. "
+                 "Go back to **Data Lab** and redefine the ROI.")
+        st.stop()
+
+    rce_head    = pipe.get("rce_head")
+    has_any_cnn = any(f"cnn_head_{n}" in pipe 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()
+
+    def rce_feature_fn(patch_bgr):
+        return build_rce_vector(patch_bgr, active_mods)
+
+    # Algorithm Reference
+    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")
+
+    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 pipe]
+        head_options.extend(trained_cnns)
+        selected_head = st.selectbox("Recognition Head", head_options,
+                                      key="gen_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 = pipe[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"),
+            key=f"gen_chk_{name}")
+
+    any_selected = any(algo_checks.values())
+
+    # 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="gen_loc_stride")
+    conf_thresh = sp2.slider("Confidence Threshold", 0.5, 1.0, 0.7, 0.05,
+                              key="gen_loc_conf")
+    nms_iou     = sp3.slider("NMS IoU Threshold", 0.1, 0.9, 0.3, 0.05,
+                              key="gen_loc_nms")
+
+    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="gen_pyr_min")
+            pyr_max = st.slider("Max Scale", 1.0, 2.0, 1.5, 0.1, key="gen_pyr_max")
+            pyr_n = st.slider("Number of Scales", 3, 7, 5, key="gen_pyr_n")
+        with pa2:
+            st.markdown("**Coarse-to-Fine**")
+            c2f_factor = st.slider("Coarse Factor", 2, 8, 4, key="gen_c2f_factor")
+            c2f_radius = st.slider("Refine Radius (strides)", 1, 5, 2, key="gen_c2f_radius")
+        with pa3:
+            st.markdown("**Contour Proposals**")
+            cnt_low = st.slider("Canny Low", 10, 100, 50, key="gen_cnt_low")
+            cnt_high = st.slider("Canny High", 50, 300, 150, key="gen_cnt_high")
+            cnt_tol = st.slider("Area Tolerance", 1.5, 10.0, 3.0, 0.5, key="gen_cnt_tol")
+
+    st.caption(
+        f"Window: **{win_w}×{win_h} px**  ·  "
+        f"Image: **{test_img.shape[1]}×{test_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,
+                         key="gen_loc_run")
+
+    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 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(
+                    test_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(
+                    test_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(
+                    test_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(
+                    test_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(
+                    test_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
+        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))
+
+                vis = test_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)
+
+                hmap = r["heatmap"]
+                if hmap.max() > 0:
+                    hmap_color = cv2.applyColorMap(
+                        (hmap / hmap.max() * 255).astype(np.uint8),
+                        cv2.COLORMAP_JET)
+                    blend = cv2.addWeighted(test_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.")
+
+                if name in edge_maps:
+                    st.image(edge_maps[name],
+                             caption="Canny Edge Map",
+                             use_container_width=True, clamp=True)
+
+                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}")
+
+                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)
+
+        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)