feat: XOR/XNOR gate discrimination via output-bubble filter

- Add filter_output_bubble() to Postprocessor: probes the right-center
region of template and candidates for a compact filled blob (bubble).
Bidirectional: rejects XNOR when XOR pattern given, and vice versa.
- Auto-detect scale range in complex template micro passes: small scales
[0.30-0.60] added only when standard passes find 0 NCC candidates,
indicating drawing instances are much smaller than the template (e.g.
gate symbols at ~40% template size). Prevents extra FPs for BR/resistors.
- Bubble filter gated on _no_std_candidates AND gate-like AR (0.25-2.0)
to avoid false rejection for bridge rectifiers and elongated templates.

Result: XOR gate detection finds exactly 5 (4 circuit + 1 notes icon),
XNOR gates correctly excluded. All 10 unit tests pass. Existing cases
(resistor x10, BR x4, example2 x4) unaffected.

src/pipeline.py

@@ -164,11 +164,18 @@ class PatternDetectionPipeline:
                 # Complex templates: separate near-0° (3a) and near-90° (3b) micro passes.
                 # Standard passes 1+2 only sweep ±10° around 0°, so pass 3b is the only
                 # path for 90°-rotated components (e.g. bridge rectifiers mounted vertically).
-                # Scales cover [0.70–1.35] so rotated components at their natural drawing
-                # size are found (pass 2 relaxed scales stop at 0.85 minimum).
-                # Same relaxed NCC threshold as pass 2 — BR components score ~0.28–0.40
-                # even at their correct scale/rotation, so 0.45 misses them entirely.
-                _complex_scales = [0.70, 0.85, 1.0, 1.1, 1.2, 1.35]
+                #
+                # Small scales (0.30–0.60) are ONLY added when standard passes 1+2 found
+                # zero NCC candidates — this indicates the drawing instances are much
+                # smaller than the template (e.g. gate symbols at ~40% template size).
+                # When passes 1+2 already found candidates, standard scale range suffices
+                # (e.g. bridge rectifiers at 70–135% template size), and adding small
+                # scales would introduce false-positive small-feature matches.
+                _no_std_candidates = len(all_candidates) == 0
+                if _no_std_candidates:
+                    _complex_scales = [0.30, 0.35, 0.40, 0.45, 0.50, 0.60, 0.70, 0.85, 1.0, 1.1, 1.2, 1.35]
+                else:
+                    _complex_scales = [0.70, 0.85, 1.0, 1.1, 1.2, 1.35]
                 self.ncc_matcher.ncc_threshold = 0.28
 
                 # Sub-pass 3a: near-0° at smaller/wider scales than standard pass
@@ -191,7 +198,30 @@ class PatternDetectionPipeline:
                 ) if cands_3b else []
                 print(f"[Pipeline] Pass 3b (micro 90°): {len(cands_3b)} cands -> {len(verified_3b)} verified")
 
-                verified = verified + verified_3a + verified_3b
+                all_complex = verified + verified_3a + verified_3b
+
+                # Output-bubble filter: distinguishes gates that differ only by a
+                # small filled circle at the output terminal (e.g. XOR vs XNOR).
+                #
+                # Applied only when BOTH conditions hold:
+                # 1. Small scales were used (_no_std_candidates=True): the template is
+                #    a gate-like symbol much smaller than the drawing instances, meaning
+                #    the output-bubble probe is geometrically meaningful.
+                # 2. Template has gate-like AR (0.25–2.0): very elongated templates
+                #    (AR > 2.0, e.g. resistors) or very wide templates have no clear
+                #    directional "output" side, so the right-center probe is unreliable.
+                #
+                # This avoids false rejection for bridge rectifiers (AR ≈ 1.0 but
+                # passes 1+2 find standard-scale candidates) and resistors (AR > 2.0).
+                _is_gate_like = 0.25 <= _tmpl_ar <= 2.0
+                if _no_std_candidates and _is_gate_like:
+                    before_bubble = len(all_complex)
+                    all_complex = self.postprocessor.filter_output_bubble(
+                        all_complex, drawing_proc, pattern_proc
+                    )
+                    if len(all_complex) != before_bubble:
+                        print(f"[Pipeline] Bubble filter: {before_bubble} -> {len(all_complex)}")
+                verified = all_complex
 
             self.ncc_matcher.scales  = _saved_scales
             self.ncc_matcher.ncc_threshold = _saved_ncc

src/postprocessor.py

@@ -913,6 +913,74 @@ class Postprocessor:
                 result.append(c)
         return result
 
+    def filter_output_bubble(
+        self,
+        candidates: List[dict],
+        drawing_gray: np.ndarray,
+        pattern_gray: np.ndarray,
+        min_blob_area: int = 8,
+        max_blob_area: int = 800,
+        min_blob_fill: float = 0.30,
+    ) -> List[dict]:
+        """Distinguish gates that differ only by an output bubble (e.g. XOR vs XNOR).
+
+        Probes the output side (right-center) of the template and each candidate.
+        If the template has NO bubble, candidates WITH a bubble are rejected.
+        If the template HAS a bubble, candidates WITHOUT a bubble are rejected.
+        Bidirectional: works for both XOR-as-query and XNOR-as-query cases.
+        """
+        ph, pw = pattern_gray.shape[:2]
+        t_has_bubble = self._probe_output_bubble(
+            pattern_gray, 0, 0, pw, ph, pw, ph,
+            min_blob_area, max_blob_area, min_blob_fill,
+        )
+        result = []
+        H, W = drawing_gray.shape[:2]
+        for c in candidates:
+            x, y, w, h = c["x"], c["y"], c["w"], c["h"]
+            c_has_bubble = self._probe_output_bubble(
+                drawing_gray, x, y, w, h, W, H,
+                min_blob_area, max_blob_area, min_blob_fill,
+            )
+            if t_has_bubble == c_has_bubble:
+                result.append(c)
+        return result
+
+    def _probe_output_bubble(
+        self,
+        img: np.ndarray,
+        x: int,
+        y: int,
+        w: int,
+        h: int,
+        W: int,
+        H: int,
+        min_blob_area: int = 8,
+        max_blob_area: int = 800,
+        min_blob_fill: float = 0.30,
+    ) -> bool:
+        """Return True if a compact filled blob exists at the right-center output side."""
+        px1 = x + int(w * 0.75)
+        px2 = min(W, x + w + int(w * 0.15))
+        py1 = y + int(h * 0.38)
+        py2 = y + int(h * 0.62)
+        if px2 <= px1 or py2 <= py1:
+            return False
+        probe = img[py1:py2, px1:px2]
+        inv = (probe < 128).astype(np.uint8) * 255
+        n_labels, _, stats, _ = cv2.connectedComponentsWithStats(inv)
+        for i in range(1, n_labels):
+            area = int(stats[i, cv2.CC_STAT_AREA])
+            bw = int(stats[i, cv2.CC_STAT_WIDTH])
+            bh = int(stats[i, cv2.CC_STAT_HEIGHT])
+            if bh > 0 and bw > 0:
+                ar = bw / bh
+                fill = area / (bw * bh)
+                if (min_blob_area <= area <= max_blob_area
+                        and 0.25 <= ar <= 4.0 and fill >= min_blob_fill):
+                    return True
+        return False
+
     @staticmethod
     def _overlap_ratio(a: dict, b: dict) -> float:
         """Max of IoU and containment ratio (intersection / area of smaller box).