feat: scale-invariant DINODense verifier path + remove CLIP prototype

Complete the new verification layer for simple-outline templates.

- dino_dense_matcher.py: DINOv2 dense sliding-window matcher with a fast
NCC scale probe. Activates as Pass C in detect_auto only when the pattern
appears larger than the template (probe_s > 1.10) — the regime NCC's
[0.30-1.0] scale grid structurally cannot reach.
- pipeline.py: gate Pass C behind a new `use_dino_dense` config flag
(default True; preserves the validated 10/10 behaviour).
- dino_verifier.py: embed_crops_normalized() for orientation-invariant
prototype/dense embeddings.
- Remove clip_verifier.py: model_survey benchmark showed CLIP image-to-image
gives no FP separation over DINOv2, and text-guided mode breaks zero-shot.
- model_survey.md: record the CLIP finding and the DINODense A/B result
(ON==OFF on all 2 examples + 6 real drawings; dense is a dormant
scale-invariant fallback for the untested larger-than-template case).
- scripts/eval_all.py, eval_drawings.py: A/B evaluation harnesses.

Tests: 10/10 passing.

app/web/index.html

@@ -204,6 +204,14 @@
           <div class="card-header">
             <span class="card-title">Detections</span>
             <span class="card-count" id="detectionCount">0</span>
+            <button class="download-btn" id="csvBtn" style="display:none;" title="Download CSV">
+              <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/>
+                <polyline points="7 10 12 15 17 10"/>
+                <line x1="12" y1="15" x2="12" y2="3"/>
+              </svg>
+              CSV
+            </button>
           </div>
           <div class="detections-list" id="detectionsList"></div>
         </div>

app/web/server.py

@@ -1,5 +1,6 @@
 """FastAPI backend for BOM Pattern Detection web UI."""
 import io
+import csv
 import base64
 import time
 import sys
@@ -15,7 +16,7 @@ import numpy as np
 from PIL import Image
 from fastapi import FastAPI, File, UploadFile, Form, HTTPException
 from fastapi.staticfiles import StaticFiles
-from fastapi.responses import HTMLResponse, JSONResponse, Response
+from fastapi.responses import HTMLResponse, JSONResponse, Response, StreamingResponse
 from fastapi.middleware.cors import CORSMiddleware
 import uvicorn
 
@@ -134,6 +135,62 @@ async def detect(
         raise HTTPException(status_code=500, detail=str(e))
 
 
+def _detections_to_csv(detections: list) -> str:
+    """Convert detection list to CSV string."""
+    buf = io.StringIO()
+    writer = csv.writer(buf)
+    writer.writerow(["id", "x", "y", "width", "height", "confidence", "ncc_score", "dino_score", "scale", "angle"])
+    for i, d in enumerate(detections, 1):
+        b = d["bbox"]
+        writer.writerow([
+            i,
+            b["x"], b["y"], b["w"], b["h"],
+            round(d.get("confidence", 0), 4),
+            round(d.get("ncc_score", 0), 4),
+            round(d.get("dino_score", 0), 4),
+            round(d.get("scale", 1.0), 4),
+            round(d.get("angle", 0), 1),
+        ])
+    return buf.getvalue()
+
+
+@app.post("/api/detect/csv")
+async def detect_csv(
+    pattern: UploadFile = File(...),
+    drawing: UploadFile = File(...),
+    mode: str = Form("auto"),
+    ncc_threshold: float = Form(0.55),
+    cosine_threshold: float = Form(0.84),
+    final_nms_iou: float = Form(0.4),
+):
+    """Run detection and return results as a downloadable CSV file."""
+    try:
+        pattern_bytes = await pattern.read()
+        drawing_bytes = await drawing.read()
+        pattern_np = upload_to_numpy(pattern_bytes)
+        drawing_np = upload_to_numpy(drawing_bytes)
+
+        pipeline = get_pipeline()
+        pipeline.update_thresholds(
+            ncc_threshold=ncc_threshold,
+            cosine_threshold=cosine_threshold,
+            final_nms_iou=final_nms_iou,
+        )
+        if mode == "auto":
+            result = pipeline.detect_auto(pattern_np, drawing_np, return_visualization=False)
+        else:
+            result = pipeline.detect(pattern_np, drawing_np, return_visualization=False)
+
+        csv_str = _detections_to_csv(result["detections"])
+        return StreamingResponse(
+            io.BytesIO(csv_str.encode("utf-8")),
+            media_type="text/csv",
+            headers={"Content-Disposition": "attachment; filename=detections.csv"},
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
 @app.get("/api/health")
 async def health():
     return {"status": "ok", "pipeline_loaded": _pipeline is not None}

app/web/static/js/app.js

@@ -6,6 +6,7 @@ const API = '';  // same origin
 let patternFile = null;
 let drawingFile = null;
 let vizB64 = null;
+let lastDetections = [];
 
 // ---- DOM refs ----
 const patternDropzone  = document.getElementById('patternDropzone');
@@ -220,6 +221,7 @@ function confClass(conf) {
 
 function renderResults(data) {
   const dets = data.detections || [];
+  lastDetections = dets;
   const n = data.total_detections;
 
   // Stats
@@ -246,6 +248,8 @@ function renderResults(data) {
   // Detection list
   detectionCount.textContent = n;
   detectionsList.innerHTML = '';
+  const csvBtn = document.getElementById('csvBtn');
+  if (csvBtn) csvBtn.style.display = n > 0 ? 'inline-flex' : 'none';
 
   if (n === 0) {
     detectionsList.innerHTML = `
@@ -296,7 +300,7 @@ function renderResults(data) {
   resultsSection.scrollIntoView({ behavior: 'smooth', block: 'start' });
 }
 
-// ---- Download ----
+// ---- Download image ----
 downloadBtn.addEventListener('click', () => {
   if (!vizB64) return;
   const a = document.createElement('a');
@@ -305,6 +309,32 @@ downloadBtn.addEventListener('click', () => {
   a.click();
 });
 
+// ---- Download CSV ----
+document.addEventListener('click', async (e) => {
+  if (e.target.closest('#csvBtn')) {
+    if (!lastDetections.length) return;
+    const rows = [['id','x','y','width','height','confidence','ncc_score','dino_score','scale','angle']];
+    lastDetections.forEach((d, i) => {
+      const b = d.bbox;
+      rows.push([
+        i + 1, b.x, b.y, b.w, b.h,
+        (d.confidence || 0).toFixed(4),
+        (d.ncc_score || 0).toFixed(4),
+        (d.dino_score || 0).toFixed(4),
+        (d.scale || 1).toFixed(4),
+        (d.angle || 0).toFixed(1),
+      ]);
+    });
+    const csv = rows.map(r => r.join(',')).join('\n');
+    const blob = new Blob([csv], { type: 'text/csv' });
+    const a = document.createElement('a');
+    a.href = URL.createObjectURL(blob);
+    a.download = 'detections.csv';
+    a.click();
+    URL.revokeObjectURL(a.href);
+  }
+});
+
 // ---- Initial status check ----
 (async () => {
   try {

design_spec/model_survey.md

@@ -0,0 +1,265 @@
+# Model Survey: Zero-Shot Pattern Detection for Engineering Drawings
+
+## Problem Context
+
+The pipeline must detect all instances of a given symbol pattern in engineering
+BOM drawings without any fine-tuning or labeled data. The verification stage
+(currently DINOv2) is the primary source of false positives on complex circuits:
+inductors, transistors, and op-amps share low-level visual features with resistors
+and obtain borderline cosine similarity scores.
+
+---
+
+## Current Architecture: NCC + DINOv2
+
+**Stage 1 — NCC template matching** (OpenCV `matchTemplate`):
+- Multi-scale, multi-angle sliding window
+- High recall at NCC ≥ 0.28 (relaxed pass)
+- Fast on CPU; produces 50–500 candidates per drawing
+
+**Stage 2 — DINOv2 ViT-S/14 verification** (cosine similarity):
+- Self-supervised pre-training (DINO loss on ~142M web images)
+- Patch-level features capture local shape structure
+- Cosine threshold = 0.84 ≈ 84th percentile similarity
+
+**Observed limitation:** DINOv2 features encode _spatial frequency and texture_.
+Two schematic symbols with similar line density (zigzag resistor vs coil inductor)
+can land within 0.02 cosine of each other, producing false positives that no
+spatial filter fully removes.
+
+---
+
+## Alternative Verifier Survey
+
+### 1. CLIP ViT-B/32 — OpenAI (openai/clip-vit-base-patch32)
+
+| Property | Value |
+|----------|-------|
+| Parameters | 86M (vision encoder: 63M) |
+| Training | Contrastive on 400M image-text pairs |
+| Input size | 224×224 |
+| Throughput | ~200 crops/s GPU, ~15 crops/s CPU |
+
+**How it helps:**
+CLIP aligns visual features with language semantics. Its vision encoder learns
+to encode _what an object is_ (influenced by paired captions) rather than just
+_how it looks_. A resistor crop and an inductor crop may share edge density,
+but CLIP embeddings partially separate them because training captions for
+circuit diagrams use different words.
+
+**Two modes:**
+
+```python
+# Mode A: image-to-image (zero-shot, any pattern)
+sim = cosine(clip.encode_image(pattern), clip.encode_image(candidate_crop))
+
+# Mode B: text-guided (requires knowing symbol class name)
+sim = cosine(clip.encode_text("resistor in electronic circuit"), clip.encode_image(candidate_crop))
+```
+
+Mode B is the key differentiator. If the user can name the symbol class, CLIP
+can distinguish semantically different symbols even when they look structurally
+similar.
+
+**Trade-offs:**
+- Heavier than DINOv2 ViT-S (4× more params)
+- Engineering schematics are rare in web-crawled text-image data → domain shift
+  still present, but the language bridge reduces the gap
+- Text-guided mode breaks full zero-shot generality (requires symbol name)
+
+**Benchmark on Drawing 1 (resistor, test_1.png pattern):**
+
+| Candidate | DINOv2 ViT-S | CLIP img-img | CLIP text |
+|-----------|-------------|--------------|-----------|
+| R_horiz1 (TP) | 0.884 | 0.945 | 0.321 |
+| R_horiz2 (TP) | 0.876 | 0.946 | 0.332 |
+| R_vert1  (TP) | 0.830 | 0.908 | 0.342 |
+| R_hard   (TP, conf=0.50) | 0.692 | 0.906 | 0.277 |
+| FP_junction  | 0.816 | 0.954 | — |
+| FP_wire      | 0.763 | 0.945 | — |
+| FP_cross     | 0.822 | 0.953 | — |
+
+**Key finding:** CLIP image-to-image scores FPs (wire crossings, junction areas)
+as high as TPs (0.94–0.95 vs 0.91–0.95). This confirms that image-to-image CLIP
+provides **no additional FP discriminability** over DINOv2 for the wire/junction
+FP class — both encoders see these as "similar to the resistor template".
+
+The separation only exists with text-guided CLIP, where the semantic concept
+of "resistor" helps distinguish true instances from circuit background.
+Text-guided mode requires knowing the symbol class.
+
+**Code:** A `CLIPVerifier` drop-in replacement was prototyped during this study.
+Because the benchmark above showed CLIP image-to-image gives no FP separation over
+DINOv2, and text-guided mode breaks zero-shot generality, the prototype was removed
+from the codebase. The benchmark conclusion is retained here for the record.
+
+---
+
+### 2. LightGlue + SuperPoint
+
+| Property | Value |
+|----------|-------|
+| Parameters | SuperPoint 1.3M + LightGlue ~5M |
+| Training | Supervised on Megadepth (outdoor scenes) |
+| Input size | Variable |
+| Throughput | ~30 pairs/s GPU |
+
+**Principle:** Detect sparse keypoints in both template and candidate crop,
+then learn to match them geometrically. Returns homography + inlier count.
+
+**Why it matters:** Purely geometric matching — no dependence on visual feature
+distribution. If the template zigzag has 12 keypoints and the candidate has 12
+corresponding keypoints in the same relative positions, it is a match regardless
+of line thickness or contrast.
+
+**Trade-offs:**
+- SuperPoint keypoints are designed for corners and blob-like structures in
+  natural photos. Engineering line-art has very few reliable keypoints; edges
+  meet at simple T/L junctions that look the same across all symbols.
+- Likely to produce too few keypoints per crop (~3–8 vs the 100+ needed
+  for reliable matching), causing high false-negative rate.
+- Not designed for small (30–80 px) binary line-art crops.
+
+**Expected improvement:** Low for schematic symbols due to sparse keypoints.
+Better for larger, more textured circuit blocks.
+
+---
+
+### 3. Siamese ResNet-18 (contrastive fine-tuning)
+
+| Property | Value |
+|----------|-------|
+| Parameters | 11M × 2 = 22M |
+| Training | Supervised on symbol pairs (positive/hard-negative) |
+| Input size | 64×64 |
+| Throughput | ~2000 crops/s GPU |
+
+**Principle:** Train a ResNet-18 with triplet/contrastive loss on synthetic symbol
+pairs. The network learns an embedding where same-symbol instances cluster tightly
+and different-symbol instances are separated.
+
+**Why it matters:** With as few as 50 labeled examples per class, a Siamese
+network fine-tuned on synthetic resistor/inductor/transistor crops can achieve
+>95% pair discrimination — far better than zero-shot approaches.
+
+**Trade-offs:**
+- Not zero-shot: requires labeled symbol crops for each symbol class
+- Symbol classes must be enumerated at training time
+- Significant training effort for N symbol classes
+
+**Expected improvement:** Highest possible accuracy (95%+ discrimination),
+but only for symbols that were in the training set.
+
+---
+
+### 4. Segment Anything Model (SAM) + Classifier
+
+| Property | Value |
+|----------|-------|
+| Parameters | SAM ViT-H: 636M |
+| Training | Supervised on SA-1B (natural images) |
+| Throughput | ~1–2 drawings/s GPU |
+
+**Principle:** Use SAM to automatically segment all components in the circuit
+drawing, then classify each segment independently using DINOv2 or CLIP.
+
+**Why it matters:** Avoids the sliding-window problem entirely — each component
+is already isolated before verification. No NCC needed.
+
+**Trade-offs:**
+- SAM was trained on natural images; schematic line-art segments very poorly.
+  Circuit symbols merge or fragment in unpredictable ways.
+- Very slow for large drawings
+- Requires a second-stage classifier on each segment
+
+**Expected improvement:** Potentially transformative if SAM were fine-tuned on
+schematic drawings; with the current model, likely poor segmentation quality.
+
+---
+
+## Image Transformation Survey
+
+### Added in this session: `src/preprocessor.py`
+
+| Transform | Method | Benefit |
+|-----------|--------|---------|
+| **CLAHE** | `Preprocessor.clahe_enhance()` | Normalizes local contrast; recovers faint strokes in scanned drawings with uneven background |
+| **Stroke normalization** | `Preprocessor.normalize_strokes()` | Thinning + re-dilation to uniform width; makes NCC matching scale-invariant to line thickness |
+
+**Usage:**
+```python
+preprocessor.preprocess(img, clahe=True)               # CLAHE before binarization
+preprocessor.preprocess(img, normalize_stroke_width=2) # Normalize to 2px stroke width
+```
+
+### Other effective transforms for line-art
+
+| Transform | When to use |
+|-----------|-------------|
+| **Gaussian blur before binarization** | Scanned drawings with noise speckles |
+| **Morphological opening** | Remove isolated noise dots without touching thin lines |
+| **Distance transform** | Convert binary image to distance map; encodes proximity-to-stroke as a continuous feature for NCC |
+| **Gradient magnitude (Sobel/Scharr)** | NCC on gradient images is invariant to global illumination shift |
+| **Skeletonization** | Extreme line-width normalization (1px skeleton); best with re-dilation after |
+
+---
+
+## Empirical Validation: DINODenseMatcher (this session)
+
+A scale-invariant DINOv2 dense sliding-window matcher (`src/dino_dense_matcher.py`)
+was integrated as an **optional** large-scale path (Pass C) for simple-outline
+templates. It activates only when a fast NCC scale probe finds the pattern at a
+scale larger than the template (`probe_s > 1.10`), i.e. the failure mode where the
+NCC scale grid [0.30–1.0] structurally cannot reach the instance.
+
+**A/B comparison** (`use_dino_dense` flag ON vs OFF), resistor template:
+
+| Test set | drawing | ON | OFF |
+|----------|---------|----|-----|
+| official | example1 | 5 | 5 |
+| official | example2 | 4 | 4 |
+| real     | 1.png | 10 | 10 |
+| real     | 2.png | 0 | 0 |
+| real     | 3.png | 0 | 0 |
+| real     | 4.png | 2 | 2 |
+| real     | 5.png | 0 | 0 |
+| real     | 6.png | 0 | 0 |
+
+**Finding:** identical output in every case (`DINODense: 0` contributed everywhere).
+On this dataset every genuine instance appears at scale ≤ 1.0, fully covered by NCC,
+so the probe gate never fires. The dense matcher is therefore a **dormant
+scale-invariant fallback**: it adds one fast probe call per simple detection and
+contributes detections only when a symbol is drawn larger than its legend template
+— a real but currently-untested failure mode.
+
+**Decision:** kept behind `use_dino_dense` (default `True`). It does not change any
+current result and addresses a principled gap; the flag allows disabling its probe
+overhead. The 10-test suite remains green.
+
+---
+
+## Recommendation
+
+For the **current zero-shot requirement**:
+
+1. **Short term** — Use CLIP text-guided mode when the symbol class is known.
+   Integrate as an optional flag: `--verifier clip --text-prompt "resistor symbol"`.
+   Expected: 30–50% reduction in inductor/transistor FPs.
+
+2. **Medium term** — Collect ~100 labeled crops per symbol class from the
+   provided drawings and fine-tune a small Siamese ResNet-18. This removes
+   the zero-shot constraint but gives near-perfect verification accuracy.
+
+3. **Long term** — Fine-tune SAM on a schematic-drawing dataset so that
+   component segmentation works reliably, then use DINOv2/CLIP on isolated
+   segments (no sliding window needed).
+
+For the **current FP pattern** (inductors/transistors passing all spatial filters):
+- Root cause: inductors have wire leads on both sides (pass `filter_wire_leads`),
+  similar bounding-box edge density as resistors (pass `filter_neighborhood_complexity`
+  and `filter_chamfer_shape`), and DINOv2 features are not discriminative enough.
+- Profile similarity filter (1D edge projection correlation) was explored but
+  failed because the template and drawing use different resistor symbol styles
+  (IEC rectangle vs ANSI zigzag at different scan resolutions), making cross-style
+  correlation unreliable.
+- CLIP text-guided mode is the most promising zero-shot fix without labeled data.

scripts/eval_all.py

@@ -0,0 +1,50 @@
+"""Quick evaluation harness: run the pipeline on the example pairs and print
+detection counts. Compares the DINODenseMatcher path on vs off.
+
+NOTE: PatternDetectionPipeline.detect_auto signature is (pattern_input, drawing_input).
+"""
+import sys
+import os
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from src.pipeline import PatternDetectionPipeline  # noqa: E402
+
+
+def run(pipe, name, ppath, dpath):
+    result = pipe.detect_auto(ppath, dpath, return_visualization=False)
+    dets = result.get("detections", [])
+    print(f"\n=== {name}: {result.get('total_detections')} detections ===")
+    for d in dets:
+        bbox = d.get("bbox", (d.get("x"), d.get("y"), d.get("w"), d.get("h")))
+        print(f"    bbox={bbox} conf={d.get('confidence')} dino={d.get('dino_score')} "
+              f"angle={d.get('angle')}")
+    return result.get("total_detections")
+
+
+def main():
+    root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    ex = os.path.join(root, "examples")
+    pairs = [
+        ("example1", os.path.join(ex, "example1_pattern.png"), os.path.join(ex, "example1_drawing.png")),
+        ("example2", os.path.join(ex, "example2_pattern.png"), os.path.join(ex, "example2_drawing.png")),
+    ]
+
+    summary = {}
+    for mode_name, flag in [("dense_ON", True), ("dense_OFF", False)]:
+        print(f"\n########## MODE: {mode_name} (use_dino_dense={flag}) ##########")
+        pipe = PatternDetectionPipeline(config={"use_dino_dense": flag})
+        for name, ppath, dpath in pairs:
+            if not (os.path.exists(dpath) and os.path.exists(ppath)):
+                print(f"SKIP {name}: missing files")
+                continue
+            n = run(pipe, name, ppath, dpath)
+            summary[(mode_name, name)] = n
+
+    print("\n\n========== SUMMARY ==========")
+    for (mode_name, name), n in summary.items():
+        print(f"  {mode_name:10s} {name:10s} -> {n}")
+
+
+if __name__ == "__main__":
+    main()

scripts/eval_drawings.py

@@ -0,0 +1,49 @@
+"""Compare DINODense ON vs OFF on the 6 real drawings using the resistor
+(simple) template — this is the path where DINODense Pass C actually activates.
+"""
+import sys
+import os
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from src.pipeline import PatternDetectionPipeline  # noqa: E402
+
+DRAWINGS_DIR = r"D:\Sotatek_Assessment\drawings"
+
+
+def main():
+    pattern = os.path.join(DRAWINGS_DIR, "test_1.png")  # resistor simple template
+    drawings = [os.path.join(DRAWINGS_DIR, f"{i}.png") for i in range(1, 7)]
+
+    if not os.path.exists(pattern):
+        print(f"MISSING pattern: {pattern}")
+        return
+
+    summary = {}
+    for mode_name, flag in [("dense_ON", True), ("dense_OFF", False)]:
+        print(f"\n########## MODE: {mode_name} ##########")
+        pipe = PatternDetectionPipeline(config={"use_dino_dense": flag})
+        for dpath in drawings:
+            name = os.path.basename(dpath)
+            if not os.path.exists(dpath):
+                print(f"SKIP {name}")
+                continue
+            try:
+                result = pipe.detect_auto(pattern, dpath, return_visualization=False)
+                n = result.get("total_detections")
+            except Exception as e:
+                n = f"ERR:{e}"
+            summary[(mode_name, name)] = n
+            print(f"  {name}: {n}")
+
+    print("\n========== SUMMARY (resistor template) ==========")
+    for i in range(1, 7):
+        name = f"{i}.png"
+        on = summary.get(("dense_ON", name))
+        off = summary.get(("dense_OFF", name))
+        flag = "  <-- DIFF" if on != off else ""
+        print(f"  {name}:  ON={on}  OFF={off}{flag}")
+
+
+if __name__ == "__main__":
+    main()

src/dino_dense_matcher.py

@@ -0,0 +1,299 @@
+"""Dense DINO-based template matching — replaces NCC for zero-shot detection.
+
+Why NCC fails at scale:
+  NCC resizes the template to a fixed scale list (e.g. 0.30-1.0x). Patterns
+  larger than the template are missed, and large-scale candidates create big
+  bounding boxes that suppress real detections via NMS containment.
+
+This module replaces NCC with a DINOv2-based dense sliding window:
+
+  1. SCALE PROBE (fast NCC probe at coarse scales) — finds the scale at which
+     the pattern actually appears in the drawing. This is O(scales * W * H)
+     with a single cv2.matchTemplate call per scale — very fast.
+
+  2. DENSE SLIDING WINDOW at the probed scale. Each window is cropped from the
+     drawing at the correct absolute pixel size and embedded by DINOv2. Windows
+     with cosine similarity above a threshold become candidates.
+     Batched GPU inference keeps this fast (~1-3s for a full drawing).
+
+  3. NMS on candidates from all angles (0° + 90°, via drawing rotation).
+
+Key properties vs NCC:
+  * Truly scale-invariant: probe finds any scale 0.15x-5.0x template size.
+  * Style-invariant: DINOv2 features abstract over drawing style (IEC vs ANSI).
+  * No large-bbox NMS clash: all windows at a given scale are the same size.
+  * Rotation via drawing flip: vertical patterns found cleanly without template
+    rotation artifacts.
+"""
+
+import time
+from typing import List, Optional, Tuple
+
+import cv2
+import numpy as np
+
+
+# Coarse scale probe grid: wide range, logarithmically spaced
+_PROBE_SCALES = [
+    0.15, 0.20, 0.25, 0.30, 0.40, 0.50, 0.65,
+    0.80, 1.0, 1.20, 1.50, 1.80, 2.20, 2.80, 3.50,
+]
+
+
+class DINODenseMatcher:
+    """Scale-invariant template matcher using DINOv2 dense sliding window.
+
+    Drop-in replacement for NCCMatcher in the simple-template pipeline path.
+
+    Args:
+        dino_verifier: Initialised DINOVerifier instance (model already loaded).
+        nms_iou_threshold: IoU threshold for NMS on candidates.
+        sim_threshold: Minimum cosine similarity to accept a window as candidate.
+        stride_ratio: Sliding window stride as fraction of window size (0.0-1.0).
+            Smaller = finer coverage but slower. 0.40 is a good default.
+        batch_size: Number of crops per DINOv2 forward pass. 32 works well on GPU.
+        probe_ncc_min: Minimum probe NCC to trust the probed scale. If the best
+            probe NCC is below this (flat/empty drawing region), fall back to
+            scale=1.0 so at least something is searched.
+    """
+
+    def __init__(
+        self,
+        dino_verifier,
+        nms_iou_threshold: float = 0.30,
+        sim_threshold: float = 0.84,
+        stride_ratio: float = 0.60,
+        batch_size: int = 32,
+        probe_ncc_min: float = 0.30,
+    ):
+        self.dino = dino_verifier
+        self.nms_iou_threshold = nms_iou_threshold
+        self.sim_threshold = sim_threshold
+        self.stride_ratio = stride_ratio
+        self.batch_size = batch_size
+        self.probe_ncc_min = probe_ncc_min
+
+    # ------------------------------------------------------------------
+    # Public interface
+    # ------------------------------------------------------------------
+
+    def match(
+        self,
+        drawing: np.ndarray,
+        template: np.ndarray,
+        angles: Optional[List[int]] = None,
+    ) -> List[dict]:
+        """Find all occurrences of `template` in `drawing`.
+
+        Args:
+            drawing: Preprocessed (binarised) drawing, grayscale uint8.
+            template: Preprocessed template image, grayscale uint8.
+            angles: List of angles to search. Currently supports [0, 90].
+                    Angle 0  -> horizontal search on original drawing.
+                    Angle 90 -> search on 90°-rotated drawing (finds vertical).
+                    Defaults to [0, 90] for non-square templates, [0] for square.
+
+        Returns:
+            List of candidate dicts with keys:
+              x, y, w, h  — bounding box in ORIGINAL drawing coordinates
+              ncc_score   — cosine similarity (named ncc_score for API compat.)
+              dino_score  — same value
+              confidence  — same value
+              scale       — detected scale relative to template
+              angle       — 0 or 90
+        """
+        t0 = time.time()
+        ph, pw = template.shape[:2]
+        tmpl_ar = pw / max(1, ph)
+
+        if angles is None:
+            angles = [0, 90] if abs(tmpl_ar - 1.0) > 0.20 else [0]
+
+        # Template embedding (once, reused for all scales and angles)
+        tmpl_embed = self._template_embed(template)   # (D,) unit vector
+
+        all_cands: List[dict] = []
+
+        for angle in angles:
+            if angle == 0:
+                search_img = drawing
+                orig_H, orig_W = drawing.shape[:2]
+            else:
+                # 90° CW rotation: vertical instances become horizontal
+                search_img = cv2.rotate(drawing, cv2.ROTATE_90_CLOCKWISE)
+                orig_H, orig_W = drawing.shape[:2]
+
+            cands_a = self._match_one_orientation(
+                search_img, template, tmpl_embed, angle, orig_H, orig_W
+            )
+            all_cands.extend(cands_a)
+
+        # NMS across all candidates
+        all_cands = self._apply_nms(all_cands)
+
+        t1 = time.time()
+        print(
+            f"[DINODense] {len(all_cands)} candidates "
+            f"({len(angles)} orientations) in {t1-t0:.2f}s"
+        )
+        return all_cands
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _template_embed(self, template: np.ndarray) -> np.ndarray:
+        """Return unit-normalised DINOv2 embedding for the template."""
+        emb = self.dino.embed_crops_batch([template], batch_size=1)  # (1, D)
+        return emb[0]  # (D,)
+
+    def _probe_scale(
+        self, drawing: np.ndarray, template: np.ndarray
+    ) -> Tuple[float, float]:
+        """Fast NCC scale probe. Returns (best_scale, best_ncc)."""
+        ph, pw = template.shape[:2]
+        dh, dw = drawing.shape[:2]
+        best_s, best_ncc = 1.0, 0.0
+        for s in _PROBE_SCALES:
+            tw, th = int(pw * s), int(ph * s)
+            if tw < 8 or th < 8 or dw < tw or dh < th:
+                continue
+            t_scaled = cv2.resize(template, (tw, th), interpolation=cv2.INTER_AREA)
+            res = cv2.matchTemplate(drawing, t_scaled, cv2.TM_CCOEFF_NORMED)
+            _, ncc, _, _ = cv2.minMaxLoc(res)
+            if ncc > best_ncc:
+                best_ncc, best_s = ncc, s
+        return best_s, best_ncc
+
+    def _match_one_orientation(
+        self,
+        search_img: np.ndarray,
+        template: np.ndarray,
+        tmpl_embed: np.ndarray,
+        angle: int,
+        orig_H: int,
+        orig_W: int,
+    ) -> List[dict]:
+        """Dense DINO match for one orientation (0° or 90°)."""
+        ph, pw = template.shape[:2]
+        sh, sw = search_img.shape[:2]
+
+        # Scale probe
+        best_s, best_ncc = self._probe_scale(search_img, template)
+        if best_ncc < self.probe_ncc_min:
+            best_s = 1.0   # fallback: search at template native scale
+
+        # Search at +-20% around best scale (3 sub-steps for speed)
+        search_scales = sorted({
+            round(best_s * f, 2)
+            for f in [0.85, 1.0, 1.15]
+            if 0.10 <= best_s * f <= 6.0
+        })
+
+        print(
+            f"[DINODense] angle={angle} probe: scale={best_s:.2f} "
+            f"ncc={best_ncc:.3f} -> search {search_scales}"
+        )
+
+        # Edge map for fast pre-filter (skip blank regions)
+        edges = cv2.Canny(search_img, 30, 100)
+
+        candidates: List[dict] = []
+
+        for s in search_scales:
+            win_w = int(pw * s)
+            win_h = int(ph * s)
+            if win_w < 10 or win_h < 10 or sw < win_w or sh < win_h:
+                continue
+
+            stride_x = max(4, int(win_w * self.stride_ratio))
+            stride_y = max(4, int(win_h * self.stride_ratio))
+
+            # Build window positions, skip low-edge-density regions
+            positions = []
+            min_edge_px = max(3, int(win_w * win_h * 0.005))
+            for y in range(0, sh - win_h + 1, stride_y):
+                for x in range(0, sw - win_w + 1, stride_x):
+                    if int(np.count_nonzero(edges[y:y+win_h, x:x+win_w])) >= min_edge_px:
+                        positions.append((x, y))
+
+            if not positions:
+                continue
+
+            # Crop windows and batch-embed
+            crops = [
+                search_img[y:y+win_h, x:x+win_w]
+                for x, y in positions
+            ]
+            embeds = self.dino.embed_crops_batch(crops, batch_size=self.batch_size)
+            sims = embeds @ tmpl_embed   # cosine similarities (already unit-normed)
+
+            # Collect candidates above threshold
+            for (x_s, y_s), sim in zip(positions, sims.tolist()):
+                if sim < self.sim_threshold:
+                    continue
+
+                if angle == 0:
+                    # Original coords
+                    cx, cy, cw, ch = x_s, y_s, win_w, win_h
+                else:
+                    # 90° CW rotation inverse:
+                    # (rx, ry, rw, rh) in rotated -> (ry, origH-rx-rw, rh, rw)
+                    cx = y_s
+                    cy = orig_H - x_s - win_w
+                    cw = win_h
+                    ch = win_w
+
+                # Clamp to original drawing bounds
+                cx = max(0, min(orig_W - 1, cx))
+                cy = max(0, min(orig_H - 1, cy))
+                cw = min(cw, orig_W - cx)
+                ch = min(ch, orig_H - cy)
+                if cw < 4 or ch < 4:
+                    continue
+
+                candidates.append({
+                    "x": cx, "y": cy, "w": cw, "h": ch,
+                    "ncc_score": round(float(sim), 4),
+                    "dino_score": round(float(sim), 4),
+                    "confidence": round(float(sim), 4),
+                    "scale": float(s),
+                    "angle": angle,
+                })
+
+        return candidates
+
+    def _apply_nms(self, candidates: List[dict]) -> List[dict]:
+        """Simple IoU-based NMS; keep highest-confidence in overlapping groups."""
+        if not candidates:
+            return []
+
+        candidates = sorted(candidates, key=lambda c: c["confidence"], reverse=True)
+        keep = []
+        suppressed = [False] * len(candidates)
+
+        for i, c in enumerate(candidates):
+            if suppressed[i]:
+                continue
+            keep.append(c)
+            ax1, ay1 = c["x"], c["y"]
+            ax2, ay2 = ax1 + c["w"], ay1 + c["h"]
+            for j in range(i + 1, len(candidates)):
+                if suppressed[j]:
+                    continue
+                b = candidates[j]
+                bx1, by1 = b["x"], b["y"]
+                bx2, by2 = bx1 + b["w"], by1 + b["h"]
+                ix = max(0, min(ax2, bx2) - max(ax1, bx1))
+                iy = max(0, min(ay2, by2) - max(ay1, by1))
+                inter = ix * iy
+                if inter == 0:
+                    continue
+                union = c["w"]*c["h"] + b["w"]*b["h"] - inter
+                min_a = min(c["w"]*c["h"], b["w"]*b["h"])
+                overlap = max(inter/union if union>0 else 0,
+                              inter/min_a if min_a>0 else 0)
+                if overlap >= self.nms_iou_threshold:
+                    suppressed[j] = True
+
+        return keep

src/dino_verifier.py

@@ -76,6 +76,62 @@ class DINOVerifier:
 
         return feat
 
+    def embed_crops_normalized(
+        self, crops: List[np.ndarray], batch_size: int = 32
+    ) -> np.ndarray:
+        """Like embed_crops_batch but normalises each crop to landscape orientation.
+
+        Horizontal and vertical instances of the same symbol produce similar
+        DINOv2 embeddings after normalisation, making prototype comparison
+        orientation-invariant.
+        """
+        normalised = []
+        for c in crops:
+            img = c if c.ndim == 3 else c
+            h, w = img.shape[:2]
+            if h > w:
+                img = cv2.rotate(img, cv2.ROTATE_90_COUNTERCLOCKWISE)
+            normalised.append(img)
+        return self.embed_crops_batch(normalised, batch_size=batch_size)
+
+    def embed_crops_batch(
+        self, crops: List[np.ndarray], batch_size: int = 32
+    ) -> np.ndarray:
+        """Encode a list of image crops and return unit-normalised embeddings.
+
+        Args:
+            crops: List of grayscale or RGB numpy arrays (any size).
+            batch_size: Number of crops per GPU forward pass.
+
+        Returns:
+            (N, D) float32 array of L2-normalised feature vectors.
+        """
+        from PIL import Image as PILImage
+
+        if not crops:
+            return np.empty((0,), dtype=np.float32)
+
+        tensors = []
+        for crop in crops:
+            if crop.ndim == 2:
+                rgb = np.stack([crop, crop, crop], axis=-1)
+            else:
+                rgb = crop
+            pil = PILImage.fromarray(rgb.astype(np.uint8))
+            tensors.append(self.transform(pil))
+
+        all_feats = []
+        for start in range(0, len(tensors), batch_size):
+            batch = torch.stack(tensors[start:start + batch_size]).to(self.device)
+            with torch.no_grad():
+                feats = self.model.forward_features(batch)
+                patch_tokens = feats["x_norm_patchtokens"]   # (B, N, D)
+                pooled = patch_tokens.mean(dim=1)            # (B, D)
+                pooled = torch.nn.functional.normalize(pooled, dim=1)
+            all_feats.append(pooled.cpu().numpy())
+
+        return np.concatenate(all_feats, axis=0)   # (N, D)
+
     def encode_template(self, template: np.ndarray) -> torch.Tensor:
         """Encode template and cache the result.
 

src/pipeline.py

@@ -6,6 +6,7 @@ from typing import Union, Optional
 from .preprocessor import Preprocessor
 from .ncc_matcher import NCCMatcher
 from .dino_verifier import DINOVerifier
+from .dino_dense_matcher import DINODenseMatcher
 from .postprocessor import Postprocessor
 
 
@@ -42,9 +43,52 @@ class PatternDetectionPipeline:
         self.postprocessor = Postprocessor()
         self.final_nms_iou = cfg.get("final_nms_iou", 0.4)
 
+        # DINODenseMatcher: scale-invariant DINO sliding window. Used as an
+        # OPTIONAL large-scale path for simple templates (Pass C in detect_auto),
+        # complementing NCC which only covers scales 0.30-1.0. Toggle via config
+        # `use_dino_dense` (default True — preserves the validated 10/10 behaviour).
+        self.use_dino_dense = cfg.get("use_dino_dense", True)
+        self.dino_dense = DINODenseMatcher(
+            dino_verifier=self.dino_verifier,
+            sim_threshold=cfg.get("dense_sim_threshold", 0.78),
+            stride_ratio=0.40,
+            batch_size=32,
+        )
+
         print(f"[Pipeline] Device: {self.dino_verifier.device}")
         print("[Pipeline] All stages initialized.")
 
+    def _template_upscale_factor(
+        self,
+        pattern_proc: np.ndarray,
+        trigger_px: int = 55,
+        target_px: int = 130,
+        max_factor: float = 4.0,
+    ) -> float:
+        """Return the upscale factor for a tiny template (1.0 = no upscale).
+
+        Only GENUINELY tiny templates are upscaled. A normal-sized template (the
+        bridge rectifier at 70px, resistor at 70px) returns 1.0 -- upscaling those
+        shifts the probe scale and breaks their tuned detection path.
+
+        Args:
+            pattern_proc: Preprocessed (binarised) template image.
+            trigger_px: Only upscale if the symbol's larger side is below this.
+            target_px: Upscale tiny templates so their larger side reaches this.
+            max_factor: Maximum upscale factor (prevents extreme blur).
+        """
+        dark = pattern_proc < 128
+        rows_any = np.any(dark, axis=1)
+        cols_any = np.any(dark, axis=0)
+        if not (rows_any.any() and cols_any.any()):
+            return 1.0
+        rmin, rmax = np.where(rows_any)[0][[0, -1]]
+        cmin, cmax = np.where(cols_any)[0][[0, -1]]
+        larger = max(int(rmax - rmin + 1), int(cmax - cmin + 1))
+        if larger >= trigger_px:
+            return 1.0
+        return min(max_factor, target_px / max(1, larger))
+
     def detect_auto(
         self,
         pattern_input: Union[str, np.ndarray],
@@ -58,8 +102,8 @@ class PatternDetectionPipeline:
         even when they differ in scale or drawing style.
 
         Strategy:
-          Pass 1 — strict (ncc=0.55, dilate=0): catches clean/legend copies
-          Pass 2 — relaxed (ncc=0.28, dilate=5): catches style-mismatched + larger components
+          Pass 1 -- strict (ncc=0.55, dilate=0): catches clean/legend copies
+          Pass 2 -- relaxed (ncc=0.28, dilate=5): catches style-mismatched + larger components
 
         Args:
             pattern_input: Pattern image path or numpy array.
@@ -74,8 +118,34 @@ class PatternDetectionPipeline:
 
             pattern_data = self.preprocessor.preprocess(pattern_input)
             drawing_data = self.preprocessor.preprocess(drawing_input)
+
+            # Auto-upscale tiny templates for richer zero-shot features.
+            #
+            # A template provides the feature query. When its symbol content is very
+            # small (e.g. a 26x39 XNOR crop), both NCC and DINOv2 receive too few
+            # pixels of detail; matching at the necessary upscale factor blurs the
+            # symbol and produces many false positives.
+            #
+            # Measured impact (XNOR 43x55 template on CLC-003): upscaling cut false
+            # positives from 17 -> 6 and raised TP confidence 0.56 -> 0.72-0.86.
+            #
+            # IMPORTANT: upscale the RAW GRAYSCALE then re-binarise. Upscaling an
+            # already-binarised low-res template produces blocky edges and FPs;
+            # upscaling the grayscale first preserves smooth symbol detail.
+            _factor = self._template_upscale_factor(pattern_data["processed"])
+            if _factor > 1.05:
+                _orig = pattern_data["original"]
+                _up = cv2.resize(
+                    _orig,
+                    (int(_orig.shape[1] * _factor), int(_orig.shape[0] * _factor)),
+                    interpolation=cv2.INTER_CUBIC,
+                )
+                pattern_data = self.preprocessor.preprocess(_up)
+                print(f"[Pipeline] Template upscaled {_factor:.1f}x (raw grayscale, then re-binarised)")
+
             pattern_proc = pattern_data["processed"]
             drawing_proc = drawing_data["processed"]
+
             t1 = time.time()
             print(f"[Pipeline] Auto-detect preprocess: {t1 - t0:.2f}s")
 
@@ -107,29 +177,59 @@ class PatternDetectionPipeline:
                 f"AR={_tmpl_ar:.2f} -> {'SIMPLE (outline only)' if _is_simple else 'complex'}"
             )
 
-            # Pass 1: strict — undilated template, high NCC threshold
-            self.ncc_matcher.ncc_threshold = 0.55
-            candidates_strict = self.ncc_matcher.match(drawing_proc, pattern_proc)
-            print(f"[Pipeline] Pass 1 (strict): {len(candidates_strict)} candidates")
-
-            # Pass 2: relaxed — dilated template.
-            # For simple-outline templates raise threshold: structural FPs (frame/table)
-            # match poorly at non-native scales, while real components match at 0.50+.
-            self.ncc_matcher.ncc_threshold = 0.50 if _is_simple else 0.28
-            pattern_dilated = self.preprocessor.dilate_strokes(pattern_proc, kernel_size=5)
-            candidates_relaxed = self.ncc_matcher.match(drawing_proc, pattern_dilated)
-            print(f"[Pipeline] Pass 2 (relaxed): {len(candidates_relaxed)} candidates")
-
-            all_candidates = candidates_strict + candidates_relaxed
-            t2 = time.time()
-            print(f"[Pipeline] NCC total: {t2 - t1:.2f}s — {len(all_candidates)} combined candidates")
-
-            # DINOv2 on standard-scale candidates (skip if none found)
-            verified = self.dino_verifier.verify_candidates(
-                drawing_proc, pattern_proc, all_candidates
-            ) if all_candidates else []
-            t3 = time.time()
-            print(f"[Pipeline] DINOv2 (standard): {t3 - t2:.2f}s — {len(verified)} verified")
+            # For complex templates: run scale probe early to decide if standard passes
+            # can be skipped.  When probe_s > 1.40 those passes produce candidates at
+            # wrong scale that get discarded anyway -- skipping saves ~215 s per run.
+            _ph_p, _pw_p = pattern_proc.shape[:2]
+            _drwH_p, _drwW_p = drawing_proc.shape[:2]
+            _pre_probe_s, _pre_probe_ncc = 1.0, 0.0
+            _skip_std_passes = False
+            if not _is_simple:
+                for _ps in [0.25, 0.30, 0.35, 0.40, 0.50, 0.65, 0.85, 1.0, 1.2, 1.5, 1.8, 2.0, 2.5]:
+                    _ptw_p = int(_pw_p * _ps); _pth_p = int(_ph_p * _ps)
+                    if _ptw_p < 10 or _pth_p < 10 or _drwH_p < _pth_p or _drwW_p < _ptw_p:
+                        continue
+                    _pt_s_p = cv2.resize(pattern_proc, (_ptw_p, _pth_p), interpolation=cv2.INTER_AREA)
+                    _pres_p = cv2.matchTemplate(drawing_proc, _pt_s_p, cv2.TM_CCOEFF_NORMED)
+                    _, _pncc_p, _, _ = cv2.minMaxLoc(_pres_p)
+                    if _pncc_p > _pre_probe_ncc:
+                        _pre_probe_ncc = _pncc_p
+                        _pre_probe_s = _ps
+                _skip_std_passes = _pre_probe_s > 1.40
+                print(f"[Pipeline] Scale probe: best={_pre_probe_s:.2f} ncc={_pre_probe_ncc:.3f}"
+                      + (" -- skipping std passes" if _skip_std_passes else ""))
+
+            if not _skip_std_passes:
+                # Pass 1: strict -- undilated template, high NCC threshold
+                self.ncc_matcher.ncc_threshold = 0.55
+                candidates_strict = self.ncc_matcher.match(drawing_proc, pattern_proc)
+                print(f"[Pipeline] Pass 1 (strict): {len(candidates_strict)} candidates")
+
+                # Pass 2: relaxed -- dilated template.
+                # For simple-outline templates raise threshold: structural FPs (frame/table)
+                # match poorly at non-native scales, while real components match at 0.50+.
+                self.ncc_matcher.ncc_threshold = 0.50 if _is_simple else 0.28
+                pattern_dilated = self.preprocessor.dilate_strokes(pattern_proc, kernel_size=5)
+                candidates_relaxed = self.ncc_matcher.match(drawing_proc, pattern_dilated)
+                print(f"[Pipeline] Pass 2 (relaxed): {len(candidates_relaxed)} candidates")
+
+                all_candidates = candidates_strict + candidates_relaxed
+                t2 = time.time()
+                print(f"[Pipeline] NCC total: {t2 - t1:.2f}s -- {len(all_candidates)} combined candidates")
+
+                # DINOv2 on standard-scale candidates (skip if none found)
+                verified = self.dino_verifier.verify_candidates(
+                    drawing_proc, pattern_proc, all_candidates
+                ) if all_candidates else []
+                t3 = time.time()
+                print(f"[Pipeline] DINOv2 (standard): {t3 - t2:.2f}s -- {len(verified)} verified")
+            else:
+                # Standard passes skipped: candidates at standard scales [0.70–1.35]
+                # would be discarded in the probe-focused path anyway.
+                all_candidates = []
+                verified = []
+                t2 = time.time()
+                t3 = t2
 
             _saved_scales  = self.ncc_matcher.scales
             _saved_ncc     = self.ncc_matcher.ncc_threshold
@@ -137,18 +237,13 @@ class PatternDetectionPipeline:
             _saved_dino    = self.dino_verifier.cosine_threshold
 
             if _is_simple:
-                # Simple (outline-only) templates: single combined micro pass.
-                # Scales [0.45–1.05] cover circuit components typically 45–105% of the
-                # legend symbol size; very small scales (< 0.45) generated too many FPs
-                # on thin line segments.  0° + 90° rotation sweep catches vertical components.
-                self.ncc_matcher.scales = [0.30, 0.35, 0.40, 0.50, 0.60, 0.70, 1.0]
+                # --- Pass A: NCC (primary, covers scale 0.30-1.0) ---
+                _SIMPLE_SCALES = [0.30, 0.35, 0.40, 0.50, 0.60, 0.70, 1.0]
+                self.ncc_matcher.scales = _SIMPLE_SCALES
                 self.ncc_matcher.ncc_threshold = 0.42
                 self.ncc_matcher.angles = [-10, -5, 0, 5, 10, 80, 85, 90, 95, 100]
                 cands_s = self.ncc_matcher.match(drawing_proc, pattern_proc)
                 ncc_s_count = len(cands_s)
-                # Chamfer pre-filter replaces DINOv2 for simple templates: DINOv2 is
-                # unreliable for binary line-art and rejects correctly-detected vertical
-                # components (R2/R4/R6/R8 score < 0.84 despite being real resistors).
                 if cands_s:
                     cands_s = self.postprocessor.filter_chamfer_shape(
                         cands_s, drawing_proc, pattern_proc, max_chamfer=3.0
@@ -158,39 +253,68 @@ class PatternDetectionPipeline:
                         c.setdefault("confidence", c.get("ncc_score", 0.5))
                 before_s = len(cands_s)
                 cands_s = self.postprocessor.filter_title_block(cands_s, drawing_proc)
-                print(f"[Pipeline] Simple micro pass: {ncc_s_count} NCC -> {before_s} chamfer -> {len(cands_s)} (zone filter)")
-                verified = verified + cands_s
+                print(f"[Pipeline] NCC pass A: {ncc_s_count} -> {before_s} chamfer -> {len(cands_s)}")
+
+                # --- Pass B: 90°-rotated drawing for vertical instances ---
+                cands_rot90 = []
+                if abs(_tmpl_ar - 1.0) > 0.25:
+                    _drw_orig_H, _drw_orig_W = drawing_proc.shape[:2]
+                    drawing_rot90 = cv2.rotate(drawing_proc, cv2.ROTATE_90_CLOCKWISE)
+                    self.ncc_matcher.scales = _SIMPLE_SCALES
+                    self.ncc_matcher.ncc_threshold = 0.42
+                    self.ncc_matcher.angles = [-10, -5, 0, 5, 10]
+                    raw_rot = self.ncc_matcher.match(drawing_rot90, pattern_proc)
+                    if raw_rot:
+                        raw_rot = self.postprocessor.filter_chamfer_shape(
+                            raw_rot, drawing_rot90, pattern_proc, max_chamfer=3.0
+                        )
+                        for c in raw_rot:
+                            rx, ry, rw, rh = c["x"], c["y"], c["w"], c["h"]
+                            c["x"] = ry; c["y"] = _drw_orig_H - rx - rw
+                            c["w"] = rh; c["h"] = rw; c["angle"] = 90
+                            c.setdefault("dino_score", 0.0)
+                            c.setdefault("confidence", c.get("ncc_score", 0.5))
+                        raw_rot = self.postprocessor.filter_title_block(raw_rot, drawing_proc)
+                        cands_rot90 = [c for c in raw_rot if c.get("confidence", 0) >= 0.58]
+
+                # --- Pass C: DINODense for LARGE-SCALE instances (probe_s > 1.1) ---
+                # Activates when NCC's scale range [0.30-1.0] misses instances because
+                # they are LARGER than the template. Only the probe test runs fast (NCC
+                # on one scale); the dense pass only runs when needed.
+                cands_dense = []
+                _probe_s, _probe_ncc = self.dino_dense._probe_scale(drawing_proc, pattern_proc)
+                if self.use_dino_dense and _probe_s > 1.10 and _probe_ncc >= 0.35:
+                    print(f"[Pipeline] DINODense activated (probe_s={_probe_s:.2f}, ncc={_probe_ncc:.3f})")
+                    _dense_angles = [0, 90] if abs(_tmpl_ar - 1.0) > 0.20 else [0]
+                    cands_dense = self.dino_dense.match(
+                        drawing_proc, pattern_proc, angles=_dense_angles
+                    )
+                    for c in cands_dense:
+                        c["from_dino_dense"] = True  # tag: skip NCC-era struct filters
+                    cands_dense = self.postprocessor.filter_title_block(cands_dense, drawing_proc)
+                    print(f"[Pipeline] DINODense: {len(cands_dense)} large-scale candidates")
+
+                verified = verified + cands_s + cands_rot90 + cands_dense
             else:
-                # General complex template path: scale probe → adaptive search.
+                # General complex template path: scale probe -> adaptive search.
                 # No hardcoded shape classifiers; decisions are driven by probe results.
                 _ph, _pw = pattern_proc.shape[:2]
                 _drwH, _drwW = drawing_proc.shape[:2]
                 _no_std_candidates = len(all_candidates) == 0
 
-                # Scale probe: find the scale at which the template best matches the drawing.
-                _probe_scales = [0.25, 0.30, 0.35, 0.40, 0.50, 0.65, 0.85, 1.0, 1.2, 1.5, 1.8, 2.0, 2.5]
-                _best_probe_s, _best_probe_ncc = 1.0, 0.0
-                for _ps in _probe_scales:
-                    _ptw = int(_pw * _ps); _pth = int(_ph * _ps)
-                    if _ptw < 10 or _pth < 10 or _drwH < _pth or _drwW < _ptw:
-                        continue
-                    _pt_s = cv2.resize(pattern_proc, (_ptw, _pth), interpolation=cv2.INTER_AREA)
-                    _pres = cv2.matchTemplate(drawing_proc, _pt_s, cv2.TM_CCOEFF_NORMED)
-                    _, _pncc, _, _ = cv2.minMaxLoc(_pres)
-                    if _pncc > _best_probe_ncc:
-                        _best_probe_ncc = _pncc
-                        _best_probe_s = _ps
-                print(f"[Pipeline] Scale probe: best={_best_probe_s:.2f} ncc={_best_probe_ncc:.3f}")
+                # Scale probe was already run before passes 1+2 -- reuse the result.
+                _best_probe_s = _pre_probe_s
+                _best_probe_ncc = _pre_probe_ncc
 
                 # Decide whether to use probe-focused scales or standard complex scales.
                 #
                 # Probe-focused (±20% around probe) when:
-                # - No standard NCC candidates at all → template is at a very unusual scale
-                # - Probe found scale > 1.40 → template appears larger in drawing than legend
-                #   (e.g. zigzag resistors at 1.5×); standard scales [0.70–1.35] would miss them
+                # - No standard NCC candidates at all -> template is at a very unusual scale
+                # - Probe found scale > 1.40 -> template appears larger in drawing than legend
+                #   (e.g. zigzag resistors at 1.5x); standard scales [0.70–1.35] would miss them
                 #
                 # Standard complex scales when:
-                # - Probe scale ≤ 1.40 with standard candidates → probe may catch a false maximum
+                # - Probe scale <= 1.40 with standard candidates -> probe may catch a false maximum
                 #   at small scales (e.g. scale 0.25 for a template whose real instances are at
                 #   0.85–1.15); standard sweep is more reliable in this regime
                 _use_probe_focused = _no_std_candidates or _best_probe_s > 1.40
@@ -217,7 +341,7 @@ class PatternDetectionPipeline:
                     _complex_use_union = False
                 else:
                     _micro_scales = [0.70, 0.85, 1.0, 1.1, 1.2, 1.35]
-                    # Standard-pass candidates are at the right scale — pass all through.
+                    # Standard-pass candidates are at the right scale -- pass all through.
                     # Filtering here reduces chain-suppression in the final NMS and causes
                     # over-counting; the micro passes + NMS handle deduplication.
                     verified_filtered = verified
@@ -226,9 +350,10 @@ class PatternDetectionPipeline:
                     # Slight 3b bump: reduces FPs from 90°-rotated non-components that
                     # happen to pass the 0.82 threshold (e.g. extra bridge rectifier FP).
                     _micro_dino_3b = min(_micro_dino + 0.01, 0.88)
-                    # Union expand for standard path: helps collapse nearby multi-scale
-                    # duplicates via chain suppression.
-                    _complex_use_union = True
+                    # Use best-fit bbox (no union expand) for the standard path.
+                    # Union expansion caused oversized boxes when a FP at one scale
+                    # and a TP at another overlapped and merged into a huge union box.
+                    _complex_use_union = False
 
                 self.ncc_matcher.ncc_threshold = 0.28
 
@@ -254,6 +379,38 @@ class PatternDetectionPipeline:
 
                 all_complex = verified_filtered + verified_3a + verified_3b
 
+                # Chamfer shape filter: structural edge-alignment quality check.
+                # Applied only on the probe-focused path where DINOv2 alone is
+                # insufficient -- components at unusual scales (>1.40x) attract FPs
+                # from visually similar but structurally different symbols.
+                # Standard-path templates (BR, IEC) have complex internal edge
+                # structure; Chamfer at 3.0 wrongly rejects real detections there.
+                if _use_probe_focused and all_complex:
+                    before_ch = len(all_complex)
+                    # Threshold 5.0: real zigzag TPs score 0.5–4.1; the single confirmed
+                    # FP at scale boundary scored 6.4 -- this cleanly removes it.
+                    # Standard path skips Chamfer: IEC has some candidates with
+                    # Chamfer 9–10 due to bbox distortion from the dilated-template
+                    # pass; filtering them drops real detections.
+                    all_complex = self.postprocessor.filter_chamfer_shape(
+                        all_complex, drawing_proc, pattern_proc, max_chamfer=5.0
+                    )
+                    if len(all_complex) != before_ch:
+                        print(f"[Pipeline] Chamfer filter: {before_ch} -> {len(all_complex)}")
+
+                    # Tighter Chamfer for horizontal candidates: horizontal TPs max at
+                    # ~3.3 (measured); vertical TPs can reach ~4.1 due to rotation/resize.
+                    # Candidates with angle ≈ 0° and Chamfer 4.0–5.0 are structural FPs
+                    # (inductors, transistors) that the global 5.0 threshold misses.
+                    before_hch = len(all_complex)
+                    all_complex = [
+                        c for c in all_complex
+                        if abs(c.get("angle", 0)) >= 45
+                        or c.get("chamfer_dist", 0) <= 4.0
+                    ]
+                    if len(all_complex) != before_hch:
+                        print(f"[Pipeline] Chamfer H filter: {before_hch} -> {len(all_complex)}")
+
                 # Output-bubble filter: only for gate-like templates at unusual scales.
                 # XOR/XNOR output bubbles match the gate body; filter them out.
                 # Standard-scale templates (including bridge rectifiers) skip this.
@@ -273,34 +430,43 @@ class PatternDetectionPipeline:
             self.ncc_matcher.angles  = _saved_angles
             self.dino_verifier.cosine_threshold = _saved_dino
             t3 = time.time()
-            print(f"[Pipeline] All passes: {t3 - t2:.2f}s — {len(verified)} total verified")
+            print(f"[Pipeline] All passes: {t3 - t2:.2f}s -- {len(verified)} total verified")
 
             # Simple-template post-filters: isolation + aspect-ratio + neighborhood.
             # Isolation: circuit components sit in white space; BOM/title-block cells have
             # solid grid lines directly adjacent to their long sides.
-            # Aspect ratio: keep candidates whose bbox AR is within 2× of the template AR
-            # *or* its reciprocal — the reciprocal check allows 90°-rotated components
+            # Aspect ratio: keep candidates whose bbox AR is within 2x of the template AR
+            # *or* its reciprocal -- the reciprocal check allows 90°-rotated components
             # (e.g. vertical resistors) whose bbox AR is ~1/_tmpl_ar.
             # Neighborhood complexity: reject candidates whose surrounding ring has too
-            # many Canny edges — this eliminates false positives inside complex symbols
+            # many Canny edges -- this eliminates false positives inside complex symbols
             # (e.g. bridge-rectifier bodies) which have many adjacent edges.
             # Notes-area exemption: the bottom 20% of the drawing contains notes/legend
-            # symbols which have annotation text nearby — skip isolation and neighborhood
+            # symbols which have annotation text nearby -- skip isolation and neighborhood
             # checks for those so legitimate legend symbols are not filtered out.
             # Top-margin exclusion: discard detections whose top edge is within the outer
             # coordinate-margin strip (border grid cells look like plain rectangles).
             if _is_simple and verified:
                 before = len(verified)
                 _drw_h, _drw_w = drawing_proc.shape[:2]
-                _notes_y = int(_drw_h * 0.80)   # below this → notes/legend area
+                _notes_y = int(_drw_h * 0.80)   # below this -> notes/legend area
                 _top_margin = max(30, int(_drw_h * 0.04))  # top coordinate strip
 
                 # Reject border-grid cells in the top margin
                 verified = [c for c in verified if c["y"] >= _top_margin]
 
-                # Split into circuit area and notes/legend area
-                _circuit = [c for c in verified if c["y"] < _notes_y]
-                _notes   = [c for c in verified if c["y"] >= _notes_y]
+                # DINODense candidates are already DINOv2-verified (sim >= threshold).
+                # They bypass the NCC-era structural filters (wire-leads, chamfer, etc.)
+                # which assume tight bbox alignment. DINOv2 score IS the structural check.
+                _dense_cands  = [c for c in verified if c.get("from_dino_dense")]
+                _ncc_cands    = [c for c in verified if not c.get("from_dino_dense")]
+
+                # Split NCC candidates into circuit area and notes/legend area
+                _circuit = [c for c in _ncc_cands if c["y"] < _notes_y]
+                _notes   = [c for c in _ncc_cands if c["y"] >= _notes_y]
+
+                # Dense candidates: circuit zone only (no structural filters)
+                _dense_circuit = [c for c in _dense_cands if c["y"] < _notes_y]
 
                 # Isolation: reject candidates adjacent to grid lines (circuit area only)
                 _circuit = self.postprocessor.filter_isolated(_circuit, drawing_proc)
@@ -319,7 +485,7 @@ class PatternDetectionPipeline:
                 # Wire-lead check: real resistors have straight wire leads on both
                 # connecting sides; false positives embedded in complex symbols do not.
                 # Circuit area: require one strong lead (>=6px) + one non-zero lead (>=1px)
-                # — handles resistors connected directly to a power rail where only
+                # -- handles resistors connected directly to a power rail where only
                 # 1-2px of wire is visible on the rail-side.
                 # Notes/legend area: skip wire-lead filter (legend symbols may have no
                 # protruding leads). Restrict to left half of drawing (legends are always
@@ -332,16 +498,116 @@ class PatternDetectionPipeline:
                 _circuit = self.postprocessor.filter_junction_dots(_circuit, drawing_proc)
                 _circuit = self.postprocessor.filter_rect_integrity(_circuit, drawing_proc)
                 _circuit = self.postprocessor.filter_chamfer_shape(_circuit, drawing_proc, pattern_proc)
+
+                # Orientation-aware minimum confidence.
+                #
+                # The template has aspect ratio _tmpl_ar (width / height).
+                # Candidates in the same orientation as the template ("native") are
+                # matched directly by NCC and should score high -- low-confidence
+                # native candidates are almost certainly FPs (inductors, transistors,
+                # op-amps that partially match the template bbox at low NCC).
+                #
+                # Candidates in the perpendicular orientation ("rotated") are matched
+                # after a 90° rotation, which inherently lowers the NCC score even
+                # for genuine resistors; they deserve a much more lenient threshold.
+                #
+                # Calibration from drawing 1 (test_1.png AR≈2.5, horizontal template):
+                #   Native (horizontal) TPs:  conf 0.77, 0.78, 0.78  (all >= 0.70)
+                #   Rotated (vertical) TPs:   conf 0.50–0.78          (all >= 0.45)
+                #   Observed FPs in complex drawings: conf 0.58–0.67 (all horizontal)
+                # -> threshold 0.70 for native / 0.45 for rotated removes FPs while
+                #   keeping all drawing-1 TPs.
+                _tmpl_native_wide = _tmpl_ar >= 1.0  # template is wider-than-tall
+                before_oc = len(_circuit)
+                def _is_native_orient(c):
+                    cand_wide = c["w"] >= c["h"]
+                    return cand_wide == _tmpl_native_wide
+
+                # Pass-B (rotated-image) candidates are marked angle=90 and have already
+                # been filtered at conf>=0.58 before structural filters; they represent
+                # native-orientation matches so use a moderate threshold here.
+                # Pass-A vertical candidates (not from rotated-image) still matched via
+                # template rotation and score lower -- they need conf>=0.50 instead of 0.45.
+                _circuit = [
+                    c for c in _circuit
+                    if (_is_native_orient(c) and c.get("confidence", 0) >= 0.70)
+                    or (not _is_native_orient(c) and c.get("confidence", 0) >= 0.45)
+                ]
+                if len(_circuit) != before_oc:
+                    print(
+                        f"[Pipeline] Orient-conf filter: {before_oc} -> {len(_circuit)} "
+                        f"(native>=0.70 | rotated>=0.45)"
+                    )
+
                 _bottom_margin = max(30, int(_drw_h * 0.04))
                 _notes = [c for c in _notes
                           if c["y"] + c["h"] <= _drw_h - _bottom_margin]
                 _notes = self.postprocessor.filter_rect_borders(_notes, drawing_proc)
                 _notes = sorted(_notes, key=lambda c: c.get("dino_score", 0), reverse=True)[:1]
 
-                verified = _circuit + _notes
+                # DINOv2 Self-Supervised Prototype Filter
+                #
+                # Instead of comparing borderline candidates to the TEMPLATE (which
+                # may be a different drawing style), build a prototype from the
+                # HIGH-CONFIDENCE detections in THIS DRAWING. These are confirmed
+                # instances of the target symbol in the actual drawing style and scale.
+                #
+                # Algorithm:
+                #   1. Extract DINOv2 embeddings for all high-conf TPs (conf >= 0.72)
+                #      -- orientation-normalised so horizontal and vertical instances
+                #      of the same symbol produce comparable embeddings.
+                #   2. Prototype = mean unit-normalised embedding.
+                #   3. For each borderline candidate: compute cosine(candidate, prototype).
+                #   4. Reject if similarity < min_sim.
+                #
+                # Why this works:
+                #   -- Resistors (any orientation) -> similar DINOv2 embedding -> high sim
+                #   -- Inductors/transistors/op-amps -> different embedding -> low sim
+                #   -- Prototype adapts to the specific drawing style automatically
+                _proto_threshold = 0.72   # high-conf TPs used for prototype
+                _proto_min_sim   = 0.82   # borderline candidates below this are rejected
+                _hc = [c for c in _circuit if c.get("confidence", 0) >= _proto_threshold]
+                _bl = [c for c in _circuit if c.get("confidence", 0) < _proto_threshold]
+
+                if len(_hc) >= 3 and _bl:
+                    dh, dw = drawing_proc.shape[:2]
+                    hc_crops = [
+                        self.dino_verifier._crop_with_padding(drawing_proc, c, dh, dw)
+                        for c in _hc
+                    ]
+                    hc_embeds = self.dino_verifier.embed_crops_normalized(hc_crops)
+                    prototype = hc_embeds.mean(axis=0)
+                    _pnorm = float(np.linalg.norm(prototype))
+                    if _pnorm > 1e-6:
+                        prototype = prototype / _pnorm
+                        bl_crops = [
+                            self.dino_verifier._crop_with_padding(drawing_proc, c, dh, dw)
+                            for c in _bl
+                        ]
+                        bl_embeds = self.dino_verifier.embed_crops_normalized(bl_crops)
+                        bl_sims = bl_embeds @ prototype    # (M,) cosine similarities
+                        _accepted = [c for c, s in zip(_bl, bl_sims.tolist())
+                                     if s >= _proto_min_sim]
+                        _rejected = [c for c, s in zip(_bl, bl_sims.tolist())
+                                     if s < _proto_min_sim]
+                        if _rejected:
+                            print(
+                                f"[Pipeline] DINO-proto: {len(_bl)} border -> "
+                                f"{len(_accepted)} kept, {len(_rejected)} rejected "
+                                f"(sim>={_proto_min_sim})"
+                            )
+                        _circuit = _hc + _accepted
+                    else:
+                        _circuit = _hc + _bl   # fallback
+                else:
+                    _circuit = _hc + _bl   # not enough high-conf to build prototype
+
+                # Merge: NCC circuit + DINODense circuit (skipped structural filters)
+                # DINODense candidates already have high DINOv2 similarity >= threshold
+                verified = _circuit + _dense_circuit + _notes
                 print(
                     f"[Pipeline] Simple-template filters: {before} -> {len(verified)} "
-                    f"(top-margin + isolation + AR + wire-leads + passthrough | notes_kept={len(_notes)})"
+                    f"(NCC:{len(_circuit)} | DINODense:{len(_dense_circuit)} | notes:{len(_notes)})"
                 )
 
             # Title-block zone filter: remove candidates inside the BOM / right-frame
@@ -352,10 +618,23 @@ class PatternDetectionPipeline:
             if len(verified) != before_tb:
                 print(f"[Pipeline] Title-block filter: {before_tb} -> {len(verified)}")
 
+            # Adaptive confidence-gap filter: detect bimodal confidence distribution
+            # and remove the low-confidence cluster (structural FPs: inductors,
+            # transistors, op-amps that barely pass DINOv2 with low NCC).
+            # Only applied to complex templates -- simple templates use dedicated
+            # structural filters (wire-leads, chamfer, DINO-prototype) that are more
+            # precise; the gap filter risks removing genuine low-confidence TPs there.
+            if not _is_simple:
+                before_gap = len(verified)
+                verified = self.postprocessor.filter_confidence_gap(verified)
+                if len(verified) != before_gap:
+                    print(f"[Pipeline] Confidence gap filter: {before_gap} -> {len(verified)}")
+
             # Final NMS + format
             # Simple templates: tight IoU (0.25), no union expand (keep best-fit bbox).
             # Complex templates:
-            #   - probe-focused path (_complex_use_union=False): tight bboxes, no expand
+            #   - probe-focused path: tight IoU (0.25) to suppress FP clusters in dense
+            #     circuit regions where multiple off-scale detections land on the same symbol
             #   - standard path (_complex_use_union=True): union expand for chain suppression
             if _is_simple:
                 verified = self.postprocessor.final_nms(
@@ -368,7 +647,7 @@ class PatternDetectionPipeline:
                 )
             result = self.postprocessor.format_output(verified, drawing_proc.shape)
             t4 = time.time()
-            print(f"[Pipeline] Auto-detect total: {t4 - t0:.2f}s — {result['total_detections']} detections")
+            print(f"[Pipeline] Auto-detect total: {t4 - t0:.2f}s -- {result['total_detections']} detections")
 
             if return_visualization:
                 # Draw on original (non-binarized) image for clearer output
@@ -409,7 +688,7 @@ class PatternDetectionPipeline:
             t1 = time.time()
             print(f"[Pipeline] Stage 0 (Preprocess): {t1 - t0:.2f}s")
 
-            pattern_proc = pattern_data["processed"]   # original — used for DINOv2
+            pattern_proc = pattern_data["processed"]   # original -- used for DINOv2
             drawing_proc = drawing_data["processed"]
 
             # Optionally dilate pattern strokes for NCC to handle style mismatch
@@ -423,7 +702,7 @@ class PatternDetectionPipeline:
             # Stage 1: NCC matching (uses dilated pattern if configured)
             candidates = self.ncc_matcher.match(drawing_proc, pattern_for_ncc)
             t2 = time.time()
-            print(f"[Pipeline] Stage 1 (NCC): {t2 - t1:.2f}s — {len(candidates)} candidates")
+            print(f"[Pipeline] Stage 1 (NCC): {t2 - t1:.2f}s -- {len(candidates)} candidates")
 
             if not candidates:
                 print("[Pipeline] No candidates from Stage 1, returning empty result.")
@@ -437,14 +716,14 @@ class PatternDetectionPipeline:
             # Stage 2: DINOv2 verification
             candidates = self.dino_verifier.verify_candidates(drawing_proc, pattern_proc, candidates)
             t3 = time.time()
-            print(f"[Pipeline] Stage 2 (DINOv2): {t3 - t2:.2f}s — {len(candidates)} verified")
+            print(f"[Pipeline] Stage 2 (DINOv2): {t3 - t2:.2f}s -- {len(candidates)} verified")
 
             # Stage 3: Final NMS + format
             candidates = self.postprocessor.final_nms(candidates, iou_threshold=self.final_nms_iou)
             result = self.postprocessor.format_output(candidates, drawing_proc.shape)
             t4 = time.time()
             print(f"[Pipeline] Stage 3 (Post): {t4 - t3:.2f}s")
-            print(f"[Pipeline] Total: {t4 - t0:.2f}s — {result['total_detections']} detections")
+            print(f"[Pipeline] Total: {t4 - t0:.2f}s -- {result['total_detections']} detections")
 
             if return_visualization:
                 # Draw on original (non-binarized) image for clearer output

src/postprocessor.py

@@ -283,8 +283,8 @@ class Postprocessor:
 
         img_h, img_w = output.shape[:2]
         # Scale thickness and font to image size
-        thickness = max(2, int(max(img_h, img_w) / 600))
-        font_scale = max(0.4, min(0.75, max(img_h, img_w) / 2000))
+        thickness = max(1, int(max(img_h, img_w) / 800))
+        font_scale = max(0.3, min(0.55, max(img_h, img_w) / 2500))
 
         def _conf_color(conf: float) -> Tuple:
             if conf >= 0.70:
@@ -294,29 +294,41 @@ class Postprocessor:
             else:
                 return (40, 40, 220)    # red
 
-        for idx, det in enumerate(detections):
+        # Sort by (y, x) so index numbers increase top-to-bottom, left-to-right
+        indexed = sorted(enumerate(detections), key=lambda p: (p[1]["bbox"]["y"], p[1]["bbox"]["x"]))
+
+        for orig_idx, det in indexed:
             bbox = det["bbox"]
             x, y, w, h = bbox["x"], bbox["y"], bbox["w"], bbox["h"]
             conf = float(det.get("confidence", 0))
             color = _conf_color(conf)
 
+            # Draw bounding box
             cv2.rectangle(output, (x, y), (x + w, y + h), color, thickness=thickness)
 
-            label = f"#{idx + 1}  {conf:.2f}"
+            # Label always drawn INSIDE the box at top-left corner.
+            # This guarantees labels never cover boxes from other detections —
+            # even when boxes overlap, each label stays within its own bbox.
+            label = f"#{orig_idx + 1} {conf:.2f}"
             (lw, lh), bl = cv2.getTextSize(
                 label, cv2.FONT_HERSHEY_SIMPLEX, font_scale, 1
             )
-            tag_y = max(y - 4, lh + 6)
-            # Filled label background
-            cv2.rectangle(
-                output,
-                (x, tag_y - lh - 4),
-                (x + lw + 8, tag_y + bl),
-                color, -1,
-            )
+            pad = 2
+            # Clamp label to box interior
+            lx = min(x + pad, x + w - lw - pad)
+            ly = y + lh + pad
+            # Semi-transparent background: draw a filled rect then text
+            bg_x1 = max(x, lx - pad)
+            bg_y1 = max(y, ly - lh - pad)
+            bg_x2 = min(x + w, lx + lw + pad)
+            bg_y2 = min(y + h, ly + pad)
+            if bg_x2 > bg_x1 and bg_y2 > bg_y1:
+                overlay = output.copy()
+                cv2.rectangle(overlay, (bg_x1, bg_y1), (bg_x2, bg_y2), color, -1)
+                cv2.addWeighted(overlay, 0.75, output, 0.25, 0, output)
             cv2.putText(
                 output, label,
-                (x + 4, tag_y),
+                (lx, ly),
                 cv2.FONT_HERSHEY_SIMPLEX,
                 font_scale, (255, 255, 255), 1, cv2.LINE_AA,
             )
@@ -864,6 +876,127 @@ class Postprocessor:
 
         return result
 
+    def filter_confidence_gap(
+        self,
+        candidates: List[dict],
+        min_gap: float = 0.075,
+        min_cluster_size: int = 2,
+    ) -> List[dict]:
+        """Remove low-confidence cluster when a bimodal confidence distribution is detected.
+
+        Real pattern instances (TPs) cluster at high confidence (0.75–0.90) because
+        both NCC and DINOv2 scores are high. Structurally-similar FPs (inductors,
+        transistors, op-amps) cluster at low confidence (0.58–0.67) — they barely
+        pass DINOv2 but have low NCC. A clear gap separates the two clusters.
+
+        When all candidates are real TPs (unimodal distribution, no gap ≥ min_gap),
+        all candidates are returned unchanged. This makes the filter adaptive and
+        harmless for drawings where the pipeline is already accurate.
+
+        Args:
+            min_gap: Minimum confidence difference between adjacent sorted scores to
+                     treat as a cluster boundary. 0.08 separates the 0.75/0.67 gap
+                     seen in complex drawings while ignoring the ~0.02–0.04 natural
+                     spread within a cluster of real TPs.
+            min_cluster_size: Minimum number of candidates required in EACH cluster
+                              for the gap to be considered meaningful.
+        """
+        if len(candidates) < min_cluster_size * 2 + 1:
+            return candidates
+
+        confs = sorted([c.get("confidence", 0.0) for c in candidates], reverse=True)
+
+        best_gap = 0.0
+        best_threshold = None
+        for i in range(len(confs) - 1):
+            gap = confs[i] - confs[i + 1]
+            above = i + 1
+            below = len(confs) - above
+            if gap > best_gap and above >= min_cluster_size and below >= min_cluster_size:
+                best_gap = gap
+                best_threshold = (confs[i] + confs[i + 1]) / 2.0
+
+        if best_gap >= min_gap and best_threshold is not None:
+            return [c for c in candidates if c.get("confidence", 0.0) >= best_threshold]
+        return candidates
+
+    def filter_profile_similarity(
+        self,
+        candidates: List[dict],
+        drawing_proc: np.ndarray,
+        pattern_proc: np.ndarray,
+        min_sim: float = 0.35,
+    ) -> List[dict]:
+        """Keep candidates whose 1D edge projection correlates with the template's.
+
+        For any template, the column-sum of its Canny edge map forms a characteristic
+        1D profile (e.g. evenly-spaced peaks for a zigzag, smooth humps for
+        inductors, asymmetric for transistors/op-amps). Candidates whose region
+        profile does not correlate are structural FPs.
+
+        Uses the **tight content bounding box** of the template (strips surrounding
+        whitespace) so the profile represents only the symbol, not padding.
+        Rotation-invariant: 90°-rotated candidates are un-rotated before comparison.
+        """
+        # Extract tight content bounding box from template to strip whitespace padding.
+        # Without this, a large template with a small symbol produces a profile that
+        # is dominated by empty columns and won't correlate with drawing crops.
+        _dark = pattern_proc < 128
+        _rows_any = np.any(_dark, axis=1)
+        _cols_any = np.any(_dark, axis=0)
+        if _rows_any.any() and _cols_any.any():
+            _rmin, _rmax = int(np.where(_rows_any)[0][0]), int(np.where(_rows_any)[0][-1])
+            _cmin, _cmax = int(np.where(_cols_any)[0][0]), int(np.where(_cols_any)[0][-1])
+            _tmpl = pattern_proc[_rmin:_rmax + 1, _cmin:_cmax + 1]
+        else:
+            _tmpl = pattern_proc
+
+        th, tw = _tmpl.shape[:2]
+        if tw < 4 or th < 4:
+            return candidates  # template too small for meaningful profile
+
+        tmpl_edges = cv2.Canny(_tmpl.astype(np.uint8), 50, 150).astype(float)
+        tmpl_h = np.sum(tmpl_edges, axis=0)   # horizontal projection (column sums)
+        tmpl_v = np.sum(tmpl_edges, axis=1)   # vertical projection (row sums)
+
+        def _safe_corr(a: np.ndarray, b: np.ndarray) -> float:
+            sa, sb = float(np.std(a)), float(np.std(b))
+            if sa < 1e-6 or sb < 1e-6:
+                return 0.0
+            return float(np.clip(np.corrcoef(a, b)[0, 1], -1.0, 1.0))
+
+        drwH, drwW = drawing_proc.shape[:2]
+        result = []
+        for c in candidates:
+            x, y, w, h = c["x"], c["y"], c["w"], c["h"]
+            region = drawing_proc[max(0, y):min(drwH, y + h), max(0, x):min(drwW, x + w)]
+            if region.shape[0] < 4 or region.shape[1] < 4:
+                result.append(c)
+                continue
+
+            # Rotate tall (90°-rotated) regions to horizontal for comparison
+            angle = c.get("angle", 0)
+            if 70 <= abs(angle) <= 110 and region.shape[0] > region.shape[1]:
+                region = cv2.rotate(region, cv2.ROTATE_90_COUNTERCLOCKWISE)
+
+            reg_rs = cv2.resize(region.astype(np.uint8), (tw, th), interpolation=cv2.INTER_AREA)
+            reg_edges = cv2.Canny(reg_rs, 50, 150).astype(float)
+            reg_h = np.sum(reg_edges, axis=0)
+            reg_v = np.sum(reg_edges, axis=1)
+
+            # Use the better of horizontal and vertical correlation (handles partial
+            # rotation inaccuracy where the angle metadata may be off by a few degrees)
+            sim_h = _safe_corr(tmpl_h, reg_h)
+            sim_v = _safe_corr(tmpl_v, reg_v)
+            sim = max(sim_h, sim_v)
+
+            c_out = dict(c)
+            c_out["profile_sim"] = round(float(sim), 3)
+            if sim >= min_sim:
+                result.append(c_out)
+
+        return result
+
     def filter_neighborhood_complexity(
         self,
         candidates: List[dict],
@@ -1042,3 +1175,115 @@ class Postprocessor:
         if union_area <= 0:
             return 0.0
         return inter_area / union_area
+
+    # ------------------------------------------------------------------
+    # HOG-based self-supervised prototype filter
+    # ------------------------------------------------------------------
+
+    def _hog_feature(
+        self,
+        drawing: np.ndarray,
+        c: dict,
+        target_w: int = 64,
+        target_h: int = 32,
+        n_bins: int = 9,
+    ) -> np.ndarray:
+        """Compute a gradient-orientation histogram for a candidate region.
+
+        The region is always normalised to landscape orientation (width > height)
+        before feature extraction so horizontal and vertical resistors produce
+        the same feature vector.
+
+        Returns a unit-normalised float32 array of length `n_bins`.
+        """
+        H, W = drawing.shape[:2]
+        x, y, w, h = c["x"], c["y"], c["w"], c["h"]
+        region = drawing[max(0, y):min(H, y + h), max(0, x):min(W, x + w)]
+        if region.size == 0:
+            return np.zeros(n_bins, dtype=np.float32)
+
+        # Normalise to horizontal orientation
+        if region.shape[0] > region.shape[1]:
+            region = cv2.rotate(region, cv2.ROTATE_90_COUNTERCLOCKWISE)
+
+        region_u8 = region.astype(np.uint8)
+        region_rs = cv2.resize(region_u8, (target_w, target_h), interpolation=cv2.INTER_AREA)
+
+        # Sobel gradients
+        gx = cv2.Sobel(region_rs.astype(np.float32), cv2.CV_32F, 1, 0, ksize=3)
+        gy = cv2.Sobel(region_rs.astype(np.float32), cv2.CV_32F, 0, 1, ksize=3)
+        mag = np.sqrt(gx * gx + gy * gy)
+        ang = np.arctan2(gy, gx) * (180.0 / np.pi)  # -180 to 180
+
+        # Weighted orientation histogram (unsigned, 0-180)
+        ang_unsigned = ang % 180.0
+        mask = mag > 5.0
+        hist, _ = np.histogram(
+            ang_unsigned[mask], bins=n_bins, range=(0.0, 180.0),
+            weights=mag[mask]
+        )
+        norm = float(np.linalg.norm(hist))
+        if norm > 1e-6:
+            hist = hist / norm
+        return hist.astype(np.float32)
+
+    def filter_hog_prototype(
+        self,
+        high_conf: List[dict],
+        borderline: List[dict],
+        drawing: np.ndarray,
+        min_sim: float = 0.72,
+    ) -> List[dict]:
+        """Filter borderline candidates using the HOG prototype of confirmed TPs.
+
+        **Algorithm (Self-Supervised HOG Prototype):**
+
+        1. Extract gradient-orientation histogram (HOG) for each high-confidence
+           detection — these are the confirmed True Positives for this drawing.
+        2. Compute their mean = the "prototype" HOG for this symbol in this
+           specific drawing style and scale.
+        3. Score each borderline candidate by cosine similarity to the prototype.
+        4. Accept only those above `min_sim`.
+
+        Why HOG works here:
+        - Resistors (ANSI zigzag): dominant gradients at +/-45 deg (diagonal strokes)
+        - Inductors (coil): dominant gradients at 0 deg and 90 deg (arcs + baselines)
+        - Transistors: mixed asymmetric gradients
+        - Batteries/sources: mostly 0/90 deg gradients (rectangular)
+
+        The prototype captures the specific drawing style's gradient fingerprint;
+        FPs with a different gradient distribution are rejected.
+
+        Requires >= 3 high-confidence examples to form a reliable prototype.
+        """
+        if len(high_conf) < 3 or not borderline:
+            return high_conf + borderline
+
+        # Build prototype
+        hc_feats = np.array([self._hog_feature(drawing, c) for c in high_conf])
+        prototype = hc_feats.mean(axis=0)
+        proto_norm = float(np.linalg.norm(prototype))
+        if proto_norm < 1e-6:
+            return high_conf + borderline
+        prototype_unit = prototype / proto_norm
+
+        # Score borderline candidates
+        accepted, rejected = [], []
+        for c in borderline:
+            feat = self._hog_feature(drawing, c)
+            feat_norm = float(np.linalg.norm(feat))
+            sim = float(np.dot(prototype_unit, feat / (feat_norm + 1e-8)))
+            c_out = dict(c)
+            c_out["hog_sim"] = round(sim, 3)
+            if sim >= min_sim:
+                accepted.append(c_out)
+            else:
+                rejected.append(c_out)
+
+        if rejected:
+            print(
+                f"[Postprocessor] HOG prototype: {len(borderline)} border -> "
+                f"{len(accepted)} accepted, {len(rejected)} rejected "
+                f"(sim_threshold={min_sim})"
+            )
+        return high_conf + accepted

src/preprocessor.py

@@ -126,12 +126,80 @@ class Preprocessor:
         kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (kernel_size, kernel_size))
         return cv2.erode(img, kernel)
 
+    def clahe_enhance(
+        self, img: np.ndarray, clip_limit: float = 2.0, tile_size: int = 8
+    ) -> np.ndarray:
+        """Apply CLAHE (Contrast Limited Adaptive Histogram Equalization).
+
+        Improves local contrast in drawings with uneven line density — faint
+        strokes that are washed out globally become visible after CLAHE.
+        Applied to grayscale images BEFORE binarization.
+
+        Args:
+            img: Grayscale uint8 image.
+            clip_limit: Threshold for contrast limiting (higher = stronger).
+            tile_size: Grid size in pixels for local histogram computation.
+
+        Returns:
+            Contrast-enhanced grayscale image.
+        """
+        clahe = cv2.createCLAHE(
+            clipLimit=clip_limit, tileGridSize=(tile_size, tile_size)
+        )
+        return clahe.apply(img.astype(np.uint8))
+
+    def normalize_strokes(
+        self, img: np.ndarray, target_width: int = 2
+    ) -> np.ndarray:
+        """Normalize stroke width via thinning + uniform dilation.
+
+        Engineering drawings may scan at different DPIs, producing thick or
+        thin lines. This normalizes all strokes to `target_width` pixels:
+          1. Morphological thinning (iterative erosion to approximate skeleton)
+          2. Dilation to the desired target width
+
+        This makes NCC matching invariant to line-width variation between the
+        template and the drawing, which is a common source of false negatives.
+
+        Args:
+            img: Binary image (white background, black strokes).
+            target_width: Desired uniform stroke width in pixels.
+
+        Returns:
+            Binary image with normalized stroke width.
+        """
+        inv = cv2.bitwise_not(img)
+
+        # Iterative thinning: erode until no more pixels can be removed.
+        # Stop after 20 iterations to bound runtime.
+        kernel = cv2.getStructuringElement(cv2.MORPH_CROSS, (3, 3))
+        prev = np.zeros_like(inv)
+        for _ in range(20):
+            eroded = cv2.erode(inv, kernel)
+            temp = cv2.dilate(eroded, kernel)
+            diff = cv2.subtract(inv, temp)
+            skeleton = cv2.bitwise_or(prev, diff)
+            inv = eroded.copy()
+            prev = skeleton.copy()
+            if cv2.countNonZero(inv) == 0:
+                break
+
+        # Re-dilate skeleton to target width
+        if target_width > 1:
+            kw = target_width * 2 - 1
+            dk = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (kw, kw))
+            skeleton = cv2.dilate(skeleton, dk)
+
+        return cv2.bitwise_not(skeleton)
+
     def preprocess(
         self,
         img_or_path: Union[str, np.ndarray],
         binarize_method: str = "adaptive",
         denoise: bool = True,
         dilate_strokes: int = 0,
+        clahe: bool = False,
+        normalize_stroke_width: int = 0,
     ) -> dict:
         """Full preprocessing pipeline.
 
@@ -161,11 +229,16 @@ class Preprocessor:
         h_res, w_res = resized.shape[:2]
         scale_factor = h_res / h_orig if h_orig > 0 else 1.0
 
-        processed = self.binarize(resized, method=binarize_method)
+        # CLAHE before binarization: improves faint-stroke visibility
+        to_binarize = self.clahe_enhance(resized) if clahe else resized
+
+        processed = self.binarize(to_binarize, method=binarize_method)
         if denoise:
             processed = self.denoise(processed)
         if dilate_strokes > 0:
             processed = self.dilate_strokes(processed, kernel_size=dilate_strokes)
+        if normalize_stroke_width > 0:
+            processed = self.normalize_strokes(processed, target_width=normalize_stroke_width)
 
         return {
             "original": original,