@@ -10,7 +10,23 @@ fn main() {
         .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());
+    // Env overrides for quick experiments: LOC_MAX (max_candidates), LOC_FRAC
+    // (max_region_frac), LOC_DENSITY (edge_density).
+    let env = |k: &str| std::env::var(k).ok().and_then(|v| v.parse().ok());
+    let mut opts = LocateOptions::default();
+    if let Some(v) = env("LOC_MAX") {
+        opts.max_candidates = v as usize;
+    }
+    if let Some(v) = env("LOC_FRAC") {
+        opts.max_region_frac = v;
+    }
+    if let Some(v) = env("LOC_DENSITY") {
+        opts.edge_density = v;
+    }
+    if let Some(v) = env("LOC_DOWNSCALE") {
+        opts.downscale = v as usize;
+    }
+    let cands = locate(&frame, &opts);
     let thr = anyd::imgproc::threshold::otsu_threshold(&frame);
     println!("frame {w}x{h}: {} candidates (otsu {thr})", cands.len());
     for c in &cands {
 
@@ -6,7 +6,7 @@
 
 use super::matrix::Canvas;
 use super::tables::{char_count_bits, ec_blocks, mode_from_indicator, remainder_bits};
-use super::{QrMeta, Version};
+use super::{EcLevel, Mask, QrMeta, Version};
 use crate::error::{Error, Result};
 use crate::output::{BitMatrix, Encoding};
 use crate::segment::{Mode, Segment};
@@ -28,47 +28,107 @@ impl QrDecoder {
     pub fn decode_matrix(&self, matrix: &BitMatrix) -> Result<Symbol> {
         let version = version_from_size(matrix.width(), matrix.height())?;
         let canvas = Canvas::from_matrix(version, matrix);
-        let (level, mask) = canvas
-            .read_format()
-            .ok_or_else(|| Error::undecodable("unreadable format information"))?;
 
-        // Read the masked data modules along the path, unmasking as we go.
-        let path = canvas.data_path();
-        let mut bits: Vec<bool> = Vec::with_capacity(path.len());
-        for &(x, y) in &path {
-            bits.push(canvas.get(x, y) ^ Canvas::mask_bit(mask, x, y));
+        // The format information (EC level + mask) is the most fragile part of a real
+        // capture: it lives in single-module features hugging the finder rings, exactly
+        // where blur bleeds worst. Read it if possible — but a failed (or damaged and
+        // silently mis-corrected) read is not fatal, because only 4 levels × 8 masks
+        // exist: try the read result first, then every other combination, and let
+        // Reed–Solomon arbitrate. RS makes a false accept astronomically unlikely, and
+        // a failing combination is rejected in ~µs, so the exhaustive pass costs almost
+        // nothing on grids that were going to fail anyway.
+        let read = canvas.read_format();
+        let mut last = Error::undecodable("unreadable format information");
+        if let Some((level, mask)) = read {
+            match decode_with_format(&canvas, version, level, mask) {
+                Ok(sym) => return Ok(sym),
+                Err(e) => last = e,
+            }
         }
-
-        let ecb = ec_blocks(version, level);
-        let total_cw = ecb.total_codewords();
-        // Pack to codewords, dropping trailing remainder bits.
-        if bits.len() < total_cw * 8 {
-            return Err(Error::undecodable("not enough data modules"));
+        // The exhaustive pass only makes sense on a grid that is plausibly a QR at all:
+        // image-sampling front-ends throw thousands of garbage grids from false finder
+        // triples at this decoder, and 32 RS attempts on each would dominate scan time.
+        // A real symbol keeps most of its timing-pattern alternation even when blur has
+        // wrecked the format modules; garbage reads as a coin flip.
+        if timing_score(&canvas, version) < 0.75 {
+            return Err(last);
         }
-        let mut codewords = Vec::with_capacity(total_cw);
-        for i in 0..total_cw {
-            let mut byte = 0u8;
-            for k in 0..8 {
-                byte = (byte << 1) | bits[i * 8 + k] as u8;
+        for (level, mask) in [EcLevel::L, EcLevel::M, EcLevel::Q, EcLevel::H]
+            .into_iter()
+            .flat_map(|level| (0..8).filter_map(move |m| Mask::new(m).map(|mk| (level, mk))))
+            .filter(|&combo| Some(combo) != read)
+        {
+            match decode_with_format(&canvas, version, level, mask) {
+                Ok(sym) => return Ok(sym),
+                Err(e) => last = e,
             }
-            codewords.push(byte);
         }
-        let _ = remainder_bits(version); // remainder bits already excluded above
+        Err(last)
+    }
+}
+
+/// Fraction of the two timing patterns (grid row 6 and column 6 between the finders)
+/// whose modules carry the expected dark/light alternation. `1.0` on a clean symbol;
+/// ≈`0.5` on a grid sampled from something that is not a QR.
+fn timing_score(canvas: &Canvas, version: Version) -> f32 {
+    let dim = version.size();
+    let mut ok = 0u32;
+    let mut total = 0u32;
+    for i in 8..dim - 8 {
+        let expected = i % 2 == 0;
+        ok += u32::from(canvas.get(i, 6) == expected);
+        ok += u32::from(canvas.get(6, i) == expected);
+        total += 2;
+    }
+    if total == 0 {
+        return 0.0;
+    }
+    ok as f32 / total as f32
+}
 
-        let data = deinterleave_and_correct(&codewords, &ecb)?;
-        let segments = parse_segments(&data, version)?;
+/// Decode the canvas under one assumed `(level, mask)` interpretation.
+fn decode_with_format(
+    canvas: &Canvas,
+    version: Version,
+    level: EcLevel,
+    mask: Mask,
+) -> Result<Symbol> {
+    // Read the masked data modules along the path, unmasking as we go.
+    let path = canvas.data_path();
+    let mut bits: Vec<bool> = Vec::with_capacity(path.len());
+    for &(x, y) in &path {
+        bits.push(canvas.get(x, y) ^ Canvas::mask_bit(mask, x, y));
+    }
 
-        let meta = QrMeta {
-            version,
-            ec_level: level,
-            mask,
-        };
-        Ok(Symbol::new(
-            Symbology::QrCode,
-            segments,
-            SymbolMeta::Qr(meta),
-        ))
+    let ecb = ec_blocks(version, level);
+    let total_cw = ecb.total_codewords();
+    // Pack to codewords, dropping trailing remainder bits.
+    if bits.len() < total_cw * 8 {
+        return Err(Error::undecodable("not enough data modules"));
+    }
+    let mut codewords = Vec::with_capacity(total_cw);
+    for i in 0..total_cw {
+        let mut byte = 0u8;
+        for k in 0..8 {
+            byte = (byte << 1) | bits[i * 8 + k] as u8;
+        }
+        codewords.push(byte);
     }
+    let _ = remainder_bits(version); // remainder bits already excluded above
+
+    let data = deinterleave_and_correct(&codewords, &ecb)?;
+    let segments = parse_segments(&data, version)?;
+
+    let meta = QrMeta {
+        version,
+        ec_level: level,
+        mask,
+    };
+    Ok(Symbol::new(
+        Symbology::QrCode,
+        segments,
+        SymbolMeta::Qr(meta),
+    ))
 }
 
 impl Decode for QrDecoder {
 
@@ -124,7 +124,19 @@ pub fn scan(frame: &GrayFrame<'_>) -> Result<Symbol> {
             break;
         };
         let mut dewarps = 0;
-        for located in candidates(frame, &bin) {
+        let cands = candidates(frame, &bin);
+        if std::env::var("ANYD_QR_DEBUG").is_ok() {
+            eprintln!("pass {pass}: {} candidates", cands.len());
+            for c in &cands {
+                eprintln!(
+                    "  cand dim={} ms={:.2} corners={:?}",
+                    c.dimension,
+                    c.module_size,
+                    c.corners.map(|p| (p.x as i32, p.y as i32))
+                );
+            }
+        }
+        for located in cands {
             let thr = located.threshold(&integral);
             let matrix = located.sample(frame, &thr);
             match decoder.decode_matrix(&matrix) {
@@ -227,7 +239,11 @@ fn refine_fourth_corner(
     // global Otsu cutoff. Blur and curvature can make either the better discriminator.
     let radius = (ms * 2.0).round().clamp(2.0, 64.0) as usize;
     let thresholds = [
-        ModuleThreshold::Local { integral, radius },
+        ModuleThreshold::Local {
+            integral,
+            radius,
+            bias: 1.0,
+        },
         ModuleThreshold::Global(located.threshold),
     ];
     let reach = ms * 3.0;
@@ -634,6 +650,12 @@ enum ModuleThreshold<'a> {
     Local {
         integral: &'a IntegralImage,
         radius: usize,
+        /// Multiplier applied to the local-contrast midpoint before classification.
+        /// `1.0` is the standard cut; the dewarp pass also tries shifted variants,
+        /// because directional blur bleeds ink asymmetrically and drags the true
+        /// dark/light split away from the geometric midpoint. Biased variants skip the
+        /// local-mean backstop (Reed-Solomon validates whatever they produce).
+        bias: f64,
     },
 }
 
@@ -658,7 +680,11 @@ impl Located {
             // Window a couple of modules across, so it always spans both dark and light
             // modules and its mean lands between them.
             let radius = (self.module_size * 2.0).round().clamp(2.0, 64.0) as usize;
-            ModuleThreshold::Local { integral, radius }
+            ModuleThreshold::Local {
+                integral,
+                radius,
+                bias: 1.0,
+            }
         } else {
             ModuleThreshold::Global(self.threshold)
         }
@@ -722,14 +748,20 @@ impl Located {
                         let (px, py) = map(gx, gy);
                         sample_dark_global(frame, px, py, tap, t)
                     }
-                    ModuleThreshold::Local { integral, radius } => {
+                    ModuleThreshold::Local {
+                        integral,
+                        radius,
+                        bias,
+                    } => {
                         let (cx, cy) = map(gx, gy);
-                        let midpoint = local_contrast_midpoint(frame, cx, cy, win);
+                        let midpoint = local_contrast_midpoint(frame, cx, cy, win) * bias;
+                        let backstop = (bias - 1.0).abs() < 1e-9;
                         let mut votes_dark = 0u32;
                         for &dv in &OFF {
                             for &du in &OFF {
                                 let (px, py) = map(gx + du, gy + dv);
-                                if sample_dark_local(frame, px, py, integral, radius, midpoint) {
+                                if sample_dark_local(frame, px, py, integral, radius, midpoint, backstop)
+                                {
                                     votes_dark += 1;
                                 }
                             }
@@ -810,8 +842,14 @@ fn sample_dark_local(
     integral: &IntegralImage,
     radius: usize,
     midpoint: f64,
+    backstop: bool,
 ) -> bool {
     let lum = sample_bilinear(frame, px, py);
+    if !backstop {
+        // Biased fallback variants classify on the shifted midpoint alone; the mean
+        // backstop would fight the very shift they exist to apply.
+        return lum < midpoint;
+    }
     let cx = (px.round().max(0.0) as usize).min(integral.width().saturating_sub(1));
     let cy = (py.round().max(0.0) as usize).min(integral.height().saturating_sub(1));
     let (sum, count) = integral.window_sum_count(cx, cy, radius);
@@ -1393,6 +1431,15 @@ fn dewarp_decode(
 ) -> Option<Symbol> {
     let base = collect_anchors(frame, bin, located);
     let (tg, ti) = timing_anchors(bin, located);
+    if std::env::var("ANYD_QR_DEBUG").is_ok() {
+        eprintln!(
+            "dewarp: dim={} ms={:.2} anchors={:?} timing={}",
+            located.dimension,
+            located.module_size,
+            base.as_ref().map(|a| a.grid.len()),
+            tg.len(),
+        );
+    }
 
     // Candidate anchor meshes, richest first. Timing-augmented meshes correct the module
     // pitch that scatters errors on real prints; the un-augmented mesh is kept as a fallback
@@ -1431,8 +1478,22 @@ fn dewarp_decode(
 
     let radius = (located.module_size * 2.0).round().clamp(2.0, 64.0) as usize;
     let thresholds = [
-        ModuleThreshold::Local { integral, radius },
+        ModuleThreshold::Local {
+            integral,
+            radius,
+            bias: 1.0,
+        },
         ModuleThreshold::Global(located.threshold),
+        ModuleThreshold::Local {
+            integral,
+            radius,
+            bias: 0.85,
+        },
+        ModuleThreshold::Local {
+            integral,
+            radius,
+            bias: 1.15,
+        },
     ];
     for (g, im) in &meshes {
         let Some(warp) = ThinPlateSpline::fit(g, im) else {
 
@@ -206,8 +206,34 @@ pub fn locate(frame: &GrayFrame<'_>, opts: &LocateOptions) -> Vec<Candidate> {
         family: Family,
         hit: Option<&'a FinderHit>,
     }
+    let debug = std::env::var("ANYD_LOC_DEBUG").is_ok();
+    if debug {
+        for f in &finders {
+            eprintln!(
+                "finder ({},{}) module={:.2} count={}",
+                f.x as usize * grid.scale,
+                f.y as usize * grid.scale,
+                f.module,
+                f.count
+            );
+        }
+    }
     let mut scored: Vec<Scored<'_>> = Vec::new();
     for region in regions {
+        if debug {
+            eprintln!(
+                "region ({},{})-({},{}) {:?} rh={} area={} lin_ok={} mat_ok={}",
+                region.x0 * grid.scale,
+                region.y0 * grid.scale,
+                region.x1 * grid.scale,
+                region.y1 * grid.scale,
+                region.family,
+                region.reads_horizontal,
+                region.area(),
+                linear_plausible(&grid, &region),
+                matrix_plausible(&grid, &region),
+            );
+        }
         // A finder falling inside the region upgrades it to a matrix guess and lends
         // its module size.
         let hit = enclosing_finder(&finders, &region);
 
@@ -484,6 +484,36 @@ fn real_scene_locator_precision() {
     }
 }
 
+/// Real camera photo of a version-2 QR on a *curved coffee-can label* at ≈4.6 px/module
+/// with visible vertical motion smear (`testdata/real_qr_can.png`, cropped from a
+/// hand-held 1080p frame). Three hardening layers must combine to read it, and this
+/// pins all of them:
+///
+/// - the **timing-anchored thin-plate dewarp** (both timing lines lock under the
+///   adaptive binarizations, bending the grid to the can's curvature),
+/// - the **format-information brute force** (blur wrecks the single-module format
+///   fields beyond BCH repair; only 32 (level, mask) combos exist, so RS arbitrates),
+/// - the **bias-shifted module classification** (the smear drags dark modules above
+///   the geometric local-contrast midpoint; the shifted variants recover them).
+#[cfg(feature = "cli")]
+#[test]
+fn real_can_qr_curved_blurred_decode() {
+    use anyd::GrayFrame;
+
+    let bytes = std::fs::read("testdata/real_qr_can.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");
+
+    let sym = scan(&frame).expect("curved blurred can QR must decode");
+    assert_eq!(sym.text().as_deref(), Some("https://zko.jp/ueacvj"));
+}
+
 /// Real camera photo of an EAN-13 on a *curved, glossy gold bottle* — a 256×96 crop with
 /// module pitch ≈ 2.3 px, optical blur and mild cylinder curvature. The hard-quantized
 /// [`anyd::scan1d::scan_lines`] path cannot read it: blur merges the single-module start,