detect: gate scene texture out of the locator and stop fragmenting codes

Real captures drowned the locator in noise: dense print flood-filled into
near-frame-sized 'matrix' blobs, text rows/columns passed as linear regions,
and one physical code was reported as a pile of overlapping fragments — while
a close-up code filling the frame produced no candidate at all (huge modules
leave the texture pass blind, and the size cap killed its region).

- cap regions at max_region_frac of the frame unless a confirmed finder backs
  them (a close-up code legitimately fills the frame)
- rank finder-backed regions first, then largest
- suppress a candidate overlapping an accepted one by >50% of the smaller box
- reject linear regions that are not scannable (reading extent < 0.75x bar
  extent) or whose dark mask breaks up along the bar axis like text glyphs
- band finderless matrix guesses to code-like ink coverage (22..85% dark)
- synthesize candidates from unclaimed finder hits (count >= 2)
- keep Region as the un-grown core box; grow linear quiet zones at emission
- micro-opts on the hot path: direct row slices in the tile pass, reused
  run buffer in the finder scan (~12% faster 1080p locate)

Real scenes: EAN-amid-text 16 -> 2 candidates with the barcode ranked first;
close-up QR 7 -> 1 (exact box); pure text areas now yield zero candidates.
Synthetic recall stays 100% in the bench and tests.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: MagicalTux

examples/locdebug.rs

@@ -11,7 +11,8 @@ fn main() {
         .collect();
     let frame = anyd::GrayFrame::new(&luma, w, h).unwrap();
     let cands = locate(&frame, &LocateOptions::default());
-    println!("frame {w}x{h}: {} candidates", cands.len());
+    let thr = anyd::imgproc::threshold::otsu_threshold(&frame);
+    println!("frame {w}x{h}: {} candidates (otsu {thr})", cands.len());
     for c in &cands {
         let cr = c.location.outline.corners;
         let (xs, ys): (Vec<f32>, Vec<f32>) = (
@@ -30,14 +31,28 @@ fn main() {
             .symbology
             .map(|s| format!("{:?}", s.dimension()))
             .unwrap_or("?".into());
+        // Dark fraction of the candidate box under the global Otsu split — the cheap
+        // "is this barcode-like ink coverage?" signal the locator gates on.
+        let (bx0, by0) = (x0.max(0.0) as usize, y0.max(0.0) as usize);
+        let (bx1, by1) = ((x1 as usize).min(w), (y1 as usize).min(h));
+        let mut dark = 0u64;
+        for yy in by0..by1 {
+            for xx in bx0..bx1 {
+                if luma[yy * w + xx] <= thr {
+                    dark += 1;
+                }
+            }
+        }
+        let area = ((bx1 - bx0) * (by1 - by0)).max(1) as f64;
         println!(
-            "  {fam:8} ({:.0},{:.0})-({:.0},{:.0})  {:.0}x{:.0}",
+            "  {fam:8} ({:.0},{:.0})-({:.0},{:.0})  {:.0}x{:.0}  dark {:.2}",
             x0,
             y0,
             x1,
             y1,
             x1 - x0,
-            y1 - y0
+            y1 - y0,
+            dark as f64 / area
         );
     }
 }

src/detect/finder.rs

@@ -122,13 +122,14 @@ pub(crate) fn find(grid: &DownGrid) -> Vec<FinderHit> {
     let mut centers: Vec<FinderHit> = Vec::new();
     let w = grid.width;
     let h = grid.height;
+    let mut runs: Vec<(bool, usize, i32)> = Vec::new();
     for y in 0..h {
-        // Run-length encode this row as (dark, start, len).
-        let mut runs: Vec<(bool, usize, i32)> = Vec::new();
-        let mut cur = grid.dark(0, y);
+        // Run-length encode this row as (dark, start, len), reusing one buffer.
+        runs.clear();
+        let row = &grid.dark[y * w..(y + 1) * w];
+        let mut cur = row[0];
         let mut start = 0usize;
-        for x in 1..w {
-            let d = grid.dark(x, y);
+        for (x, &d) in row.iter().enumerate().skip(1) {
             if d != cur {
                 runs.push((cur, start, (x - start) as i32));
                 cur = d;