@@ -1,20 +1,43 @@
 // Diagnostic: what does detect::locate find on a real photo?
-use anyd::detect::{locate, LocateOptions};
+use anyd::detect::{LocateOptions, locate};
 fn main() {
     let path = std::env::args().nth(1).expect("usage: locdebug <png>");
     let rgba = oxideav_png::decode_png_to_rgba(&std::fs::read(&path).unwrap()).unwrap();
     let (w, h) = (rgba.width as usize, rgba.height as usize);
-    let luma: Vec<u8> = rgba.data.chunks_exact(4)
-        .map(|p| ((p[0] as u32 * 299 + p[1] as u32 * 587 + p[2] as u32 * 114) / 1000) as u8).collect();
+    let luma: Vec<u8> = rgba
+        .data
+        .chunks_exact(4)
+        .map(|p| ((p[0] as u32 * 299 + p[1] as u32 * 587 + p[2] as u32 * 114) / 1000) as u8)
+        .collect();
     let frame = anyd::GrayFrame::new(&luma, w, h).unwrap();
     let cands = locate(&frame, &LocateOptions::default());
     println!("frame {w}x{h}: {} candidates", cands.len());
     for c in &cands {
         let cr = c.location.outline.corners;
-        let (xs, ys): (Vec<f32>, Vec<f32>) = (cr.iter().map(|p| p.x).collect(), cr.iter().map(|p| p.y).collect());
-        let (x0, y0) = (xs.iter().cloned().fold(f32::MAX, f32::min), ys.iter().cloned().fold(f32::MAX, f32::min));
-        let (x1, y1) = (xs.iter().cloned().fold(0.0, f32::max), ys.iter().cloned().fold(0.0, f32::max));
-        let fam = c.symbology.map(|s| format!("{:?}", s.dimension())).unwrap_or("?".into());
-        println!("  {fam:8} ({:.0},{:.0})-({:.0},{:.0})  {:.0}x{:.0}", x0, y0, x1, y1, x1 - x0, y1 - y0);
+        let (xs, ys): (Vec<f32>, Vec<f32>) = (
+            cr.iter().map(|p| p.x).collect(),
+            cr.iter().map(|p| p.y).collect(),
+        );
+        let (x0, y0) = (
+            xs.iter().cloned().fold(f32::MAX, f32::min),
+            ys.iter().cloned().fold(f32::MAX, f32::min),
+        );
+        let (x1, y1) = (
+            xs.iter().cloned().fold(0.0, f32::max),
+            ys.iter().cloned().fold(0.0, f32::max),
+        );
+        let fam = c
+            .symbology
+            .map(|s| format!("{:?}", s.dimension()))
+            .unwrap_or("?".into());
+        println!(
+            "  {fam:8} ({:.0},{:.0})-({:.0},{:.0})  {:.0}x{:.0}",
+            x0,
+            y0,
+            x1,
+            y1,
+            x1 - x0,
+            y1 - y0
+        );
     }
 }
@@ -18,9 +18,12 @@
 //! 2. **Concentric finders** (`finder`): a run-length row scan with a vertical
 //!    cross-check flags QR/Aztec `1:1:3:1:1` fiducials. These give a high-confidence
 //!    matrix classification and a module-size estimate.
-//! 3. **Texture tiles** (`tiles`): tiles dense with dark/light edges are clustered
-//!    into regions; the horizontal-vs-vertical edge balance separates 1D barcode
-//!    regions from 2D matrix regions, catching every finder-less symbology.
+//! 3. **Texture tiles** (`tiles`): each dense-edged tile is first *labelled* by its own
+//!    horizontal-vs-vertical edge balance — one-directional (a 1D barcode patch) or
+//!    balanced (a 2D matrix) — and only same-label tiles are then clustered into regions.
+//!    Labelling per tile before clustering is what lets a directional barcode be pulled
+//!    out of the isotropic text and artwork it sits amongst, catching every finder-less
+//!    symbology without the barcode dissolving into the surrounding scene.
 //! 4. **Merge + map back**: finder hits upgrade the region they fall in to a matrix
 //!    guess with a real module size; region boxes are scaled back to full resolution and
 //!    returned as [`Candidate`]s, ordered strongest-first and capped at
 
@@ -6,10 +6,19 @@
 //!
 //! The reduced dark mask is split into a grid of square tiles. For each tile we count
 //! horizontal and vertical dark/light transitions in one pass; a tile whose transition
-//! density clears a threshold is "active". Active tiles are grouped by 8-connected
-//! flood fill into regions, and each region's horizontal-vs-vertical transition balance
-//! gives a coarse family guess: strongly one-directional edges read as a 1D barcode,
-//! balanced edges as a 2D matrix.
+//! density clears a threshold is "active". Each active tile is then *labelled* by its
+//! own edge balance before any clustering: a tile whose horizontal and vertical
+//! transition counts are strongly one-directional is a **linear** tile (and remembers
+//! whether horizontal or vertical edges dominate), while a balanced tile is a **matrix**
+//! tile. Flood fill then groups only tiles that share the *same* label into regions.
+//!
+//! Per-tile labelling before clustering is what lets a 1D barcode be pulled out of a
+//! busy scene. A barcode is a compact patch of tiles that all lean the same way
+//! (vertical bars ⇒ horizontal-edge-dominant); the printed text and artwork around it
+//! are edge-dense too, but *isotropic*, so they label as matrix and never merge into the
+//! barcode's component. Labelling the whole active blob at once — the old approach —
+//! averaged the barcode's strong anisotropy away against the surrounding text and lost
+//! the code entirely.
 
 use super::grid::DownGrid;
 
@@ -29,6 +38,21 @@ struct TileStats {
     area: Vec<u32>,
 }
 
+/// Per-tile classification assigned before clustering. Flood fill only joins tiles that
+/// carry the same label, keeping a directional barcode patch out of the isotropic text
+/// and artwork it sits amongst.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum Label {
+    /// Below the edge-density floor: ignored.
+    Inactive,
+    /// Active and horizontal-edge-dominant (upright bars).
+    LinearH,
+    /// Active and vertical-edge-dominant (bars rotated ~90°).
+    LinearV,
+    /// Active but balanced: a 2D matrix or plain scene texture.
+    Matrix,
+}
+
 /// The coarse layout family a region is guessed to belong to.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum Family {
@@ -111,27 +135,47 @@ pub(crate) fn regions(
     let cols = stats.cols;
     let rows = stats.rows;
 
-    // Activity mask over the tile grid.
-    let active: Vec<bool> = (0..cols * rows)
+    // Per-tile label decided *before* clustering, so a tile's own edge balance — not the
+    // average over a whole merged blob — chooses its family. Flood fill later joins only
+    // tiles that carry the same label.
+    let label: Vec<Label> = (0..cols * rows)
         .map(|i| {
             let a = stats.area[i];
             if a == 0 {
-                return false;
+                return Label::Inactive;
+            }
+            let h = stats.htrans[i];
+            let v = stats.vtrans[i];
+            let total = h + v;
+            if total as f32 / (a as f32) < edge_density {
+                return Label::Inactive;
+            }
+            // Anisotropy of this single tile. Vertical bars cross many row scans and few
+            // column scans, so a barcode tile is strongly horizontal-dominant (and a
+            // 90°-rotated one vertical-dominant); text and artwork are balanced.
+            let anisotropy = (h as f32 - v as f32).abs() / total as f32;
+            if anisotropy >= aniso {
+                if h >= v {
+                    Label::LinearH
+                } else {
+                    Label::LinearV
+                }
+            } else {
+                Label::Matrix
             }
-            let density = (stats.htrans[i] + stats.vtrans[i]) as f32 / a as f32;
-            density >= edge_density
         })
         .collect();
 
-    // 8-connected flood fill over active tiles.
+    // 8-connected flood fill that only merges tiles sharing the start tile's label.
     let mut visited = vec![false; cols * rows];
     let mut stack: Vec<(usize, usize)> = Vec::new();
     let mut out = Vec::new();
 
     for sy in 0..rows {
         for sx in 0..cols {
             let start = sy * cols + sx;
-            if !active[start] || visited[start] {
+            let seed = label[start];
+            if seed == Label::Inactive || visited[start] {
                 continue;
             }
             visited[start] = true;
@@ -142,14 +186,9 @@ pub(crate) fn regions(
             let mut min_ty = sy;
             let mut max_ty = sy;
             let mut tiles = 0usize;
-            let mut h_sum = 0u64;
-            let mut v_sum = 0u64;
 
             while let Some((cx, cy)) = stack.pop() {
-                let idx = cy * cols + cx;
                 tiles += 1;
-                h_sum += u64::from(stats.htrans[idx]);
-                v_sum += u64::from(stats.vtrans[idx]);
                 min_tx = min_tx.min(cx);
                 max_tx = max_tx.max(cx);
                 min_ty = min_ty.min(cy);
@@ -162,7 +201,7 @@ pub(crate) fn regions(
                 for ny in y0..=y1 {
                     for nx in x0..=x1 {
                         let nidx = ny * cols + nx;
-                        if active[nidx] && !visited[nidx] {
+                        if !visited[nidx] && label[nidx] == seed {
                             visited[nidx] = true;
                             stack.push((nx, ny));
                         }
@@ -174,24 +213,37 @@ pub(crate) fn regions(
                 continue;
             }
 
-            let total = (h_sum + v_sum) as f32;
-            let anisotropy = if total > 0.0 {
-                (h_sum as f32 - v_sum as f32).abs() / total
-            } else {
-                0.0
-            };
-            let family = if anisotropy >= aniso {
-                Family::Linear
-            } else {
-                Family::Matrix
+            let family = match seed {
+                Label::LinearH | Label::LinearV => Family::Linear,
+                _ => Family::Matrix,
             };
 
+            // A 2D matrix code always extends in both axes; a one-tile-thin strip of
+            // balanced tiles is not one. These strips appear where a barcode's bars
+            // terminate (the row of bar-ends adds vertical edges that cancel the
+            // horizontal dominance) and as thin runs of text — reject them so the
+            // matrix family stays meaningful. Linear codes are legitimately thin.
+            if family == Family::Matrix && (max_tx - min_tx < 1 || max_ty - min_ty < 1) {
+                continue;
+            }
+
             let t = stats.tile;
+            let (mut x0, mut y0) = (min_tx * t, min_ty * t);
+            let (mut x1, mut y1) = ((max_tx + 1) * t, (max_ty + 1) * t);
+            // Barcodes read across their bars, so a linear box needs the quiet zone on
+            // each side of the bars to survive downstream scanning. Grow it one tile out
+            // (matrix codes carry their own quiet zone inside the finder search).
+            if family == Family::Linear {
+                x0 = x0.saturating_sub(t);
+                y0 = y0.saturating_sub(t);
+                x1 += t;
+                y1 += t;
+            }
             out.push(Region {
-                x0: min_tx * t,
-                y0: min_ty * t,
-                x1: ((max_tx + 1) * t).min(grid.width),
-                y1: ((max_ty + 1) * t).min(grid.height),
+                x0,
+                y0,
+                x1: x1.min(grid.width),
+                y1: y1.min(grid.height),
                 family,
             });
         }
 
@@ -312,3 +312,77 @@ fn real_bottle_photo_front_end() {
     // dewarping improvement can light it up without editing this test.
     let _ = scan(&frame);
 }
+
+/// End-to-end locate → crop → decode on a real captured photo of a 1D barcode, mirroring
+/// exactly what the live demo does per frame. `testdata/real_scene_ean.png` is a
+/// native-resolution region of a camera capture: a gold PET-bottle label with an EAN-13
+/// ("4901085663356") amid dense Japanese text and artwork.
+///
+/// This is the regression for the locator's per-tile labelling fix. Previously the whole
+/// edge-dense scene flood-filled into one frame-spanning matrix blob whose averaged
+/// anisotropy read as 2D, so the locator emitted **no** linear box on the barcode and the
+/// demo had nothing to crop-decode — even though the decoder reads the barcode fine when
+/// handed the right crop. Labelling each tile by its own edge balance before clustering
+/// keeps the barcode's directionally-coherent tiles out of the isotropic text, isolating
+/// it as a linear candidate.
+#[cfg(feature = "cli")]
+#[test]
+fn real_scene_locate_then_decode_ean() {
+    use anyd::GrayFrame;
+    use anyd::detect::{LocateOptions, locate};
+
+    let bytes = std::fs::read("testdata/real_scene_ean.png").expect("read fixture");
+    let rgba = oxideav_png::decode_png_to_rgba(&bytes).expect("decode PNG");
+    let (w, h) = (rgba.width as usize, rgba.height as usize);
+    let luma: Vec<u8> = rgba
+        .data
+        .chunks_exact(4)
+        .map(|p| ((p[0] as u32 * 299 + p[1] as u32 * 587 + p[2] as u32 * 114) / 1000) as u8)
+        .collect();
+    let frame = GrayFrame::new(&luma, w, h).expect("valid frame");
+
+    // Axis-aligned bounds of a candidate's outline, clamped to the frame.
+    let bounds = |c: &anyd::pipeline::Candidate| {
+        let cs = c.location.outline.corners;
+        let x0 = cs.iter().map(|p| p.x).fold(f32::MAX, f32::min).max(0.0) as usize;
+        let y0 = cs.iter().map(|p| p.y).fold(f32::MAX, f32::min).max(0.0) as usize;
+        let x1 = (cs.iter().map(|p| p.x).fold(0.0, f32::max) as usize).min(w);
+        let y1 = (cs.iter().map(|p| p.y).fold(0.0, f32::max) as usize).min(h);
+        (x0, y0, x1, y1)
+    };
+
+    // The barcode occupies roughly (250,205)-(790,405); its centre is ~(512,295).
+    let (bx, by) = (512usize, 295usize);
+    let cands = locate(&frame, &LocateOptions::default());
+    let bar = cands
+        .iter()
+        .find(|c| {
+            c.symbology.map(|s| s.dimension()) == Some(anyd::Dimension::Linear) && {
+                let (x0, y0, x1, y1) = bounds(c);
+                x0 <= bx && bx < x1 && y0 <= by && by < y1
+            }
+        })
+        .expect("locate() must isolate the barcode as a linear candidate over its centre");
+
+    // Crop the located box and decode it end-to-end, exactly as the demo's worker does.
+    let (x0, y0, x1, y1) = bounds(bar);
+    let (cw, ch) = (x1 - x0, y1 - y0);
+    let mut crop = vec![0u8; cw * ch];
+    for y in 0..ch {
+        for x in 0..cw {
+            crop[y * cw + x] = frame.get_unchecked(x0 + x, y0 + y);
+        }
+    }
+    let cframe = GrayFrame::new(&crop, cw, ch).expect("valid crop");
+
+    let lines = anyd::scan1d::scan_lines(&cframe, &anyd::scan1d::ScanOptions::default());
+    let dec = anyd::codes::ean::EanDecoder::new();
+    let text = lines
+        .iter()
+        .find_map(|cand| anyd::scan1d::try_decode(cand, &dec).and_then(|s| s.text()))
+        .expect("the located region must decode as EAN-13");
+    assert_eq!(
+        text, "4901085663356",
+        "wrong payload from the located barcode"
+    );
+}