@@ -87,7 +87,10 @@ sampling → decode. Robust to any-angle rotation, moderate tilt, blur and noise
 run-length → normalized `LinearPattern`), feeding each symbology's decoder. The
 end-to-end pixel→symbol path is verified for Code 128, Code 39 and EAN-13 in
 `tests/scan1d_pipeline.rs`; it applies to any standard bar/space linear code.
-DataBar (finder-pattern based) and Pharmacode need dedicated samplers.
+Through `pipeline::scan_1d` the read is rotation-complete: mirrored patterns cover
+180°, and any other angle is handled by estimating the crop's dominant texture
+orientation and derotating before the rescan (`tests/rotated1d.rs`). DataBar
+(finder-pattern based) and Pharmacode need dedicated samplers.
 
 ³ Data Matrix ships an image sampler: Otsu binarization → largest-component isolation
 → solid-L finder + timing-edge line fitting → perspective corners → `imgproc` grid
 
@@ -21,6 +21,8 @@
 //! - `sample` — [`sample_grid`], the sub-pixel bilinear grid reader that turns a
 //!   warped frame plus a homography into a [`BitMatrix`].
 //! - [`edges`] — Sobel gradient magnitude and binary morphology (erode/dilate).
+//! - [`orient`] — [`dominant_gradient_angle`], the texture-orientation estimate that
+//!   lets the 1D pipeline derotate an arbitrarily rotated barcode crop.
 //! - [`rng`] — a small explicit seeded [`Prng`] so any randomness is reproducible.
 //!
 //! Everything here is deterministic and dependency-free.
@@ -34,6 +36,7 @@ pub mod edges;
 pub mod homography;
 pub mod integral;
 pub mod line;
+pub mod orient;
 pub mod rng;
 pub mod sample;
 pub mod threshold;
@@ -45,6 +48,7 @@ pub use edges::{dilate, erode, sobel_magnitude};
 pub use homography::Homography;
 pub use integral::IntegralImage;
 pub use line::{Line, fit_line_least_squares, ransac_line};
+pub use orient::dominant_gradient_angle;
 pub use rng::Prng;
 pub use sample::{sample_bilinear, sample_grid, sample_grid_binary};
 pub use threshold::{
 
@@ -0,0 +1,158 @@
+//! Dominant gradient-orientation estimation.
+//!
+//! A linear barcode is the most orientation-coherent texture there is: every bar edge
+//! points the gradient along the *reading* axis, so the gradient-orientation histogram
+//! of a barcode crop has one overwhelming peak (modulo 180° — a gradient cannot tell a
+//! code from its upside-down self). [`dominant_gradient_angle`] measures that peak and
+//! how dominant it is, letting a scanning pipeline *derotate* a crop whose code is not
+//! within its scanline sweep instead of blindly re-scanning at every angle.
+
+use crate::image::GrayFrame;
+
+/// Histogram bins across the half-circle: 3° per bin.
+const BINS: usize = 60;
+
+/// Minimum squared gradient magnitude for a pixel to vote; rejects sensor noise and
+/// flat background so the histogram is built from real edges.
+const MIN_MAG2: f32 = 24.0 * 24.0;
+
+/// Fraction of total edge energy that must fall within ±2 bins (±7.5°) of the peak for
+/// the orientation to count as *dominant*. Barcodes score far above this; text, matrix
+/// codes and scene texture spread their energy and fall below.
+const MIN_COHERENCE: f32 = 0.4;
+
+/// Estimate the dominant edge orientation of `frame` in radians, in `(-π/2, π/2]`,
+/// measured from the +x axis — for a barcode this is the *reading* direction (bars are
+/// perpendicular to it). Returns `None` when the texture has no sufficiently dominant
+/// orientation (nothing bar-like to derotate for).
+pub fn dominant_gradient_angle(frame: &GrayFrame<'_>) -> Option<f32> {
+    let w = frame.width();
+    let h = frame.height();
+    if w < 8 || h < 8 {
+        return None;
+    }
+
+    // Histogram of gradient orientation mod π, weighted by squared magnitude.
+    let mut hist = [0.0f32; BINS];
+    let mut total = 0.0f32;
+    for y in 1..h - 1 {
+        for x in 1..w - 1 {
+            let gx = f32::from(frame.get_unchecked(x + 1, y))
+                - f32::from(frame.get_unchecked(x - 1, y));
+            let gy = f32::from(frame.get_unchecked(x, y + 1))
+                - f32::from(frame.get_unchecked(x, y - 1));
+            let mag2 = gx * gx + gy * gy;
+            if mag2 < MIN_MAG2 {
+                continue;
+            }
+            let a = gy.atan2(gx).rem_euclid(core::f32::consts::PI);
+            let bin = ((a / core::f32::consts::PI) * BINS as f32) as usize % BINS;
+            hist[bin] += mag2;
+            total += mag2;
+        }
+    }
+    if total <= 0.0 {
+        return None;
+    }
+
+    // Light circular 1-2-1 smoothing so the peak does not split across a bin edge.
+    let mut smooth = [0.0f32; BINS];
+    for i in 0..BINS {
+        let l = hist[(i + BINS - 1) % BINS];
+        let r = hist[(i + 1) % BINS];
+        smooth[i] = 0.25 * l + 0.5 * hist[i] + 0.25 * r;
+    }
+    let peak = (0..BINS)
+        .max_by(|&a, &b| smooth[a].partial_cmp(&smooth[b]).unwrap())
+        .unwrap();
+
+    // Coherence: energy near the peak vs everywhere. Uses the raw histogram so the
+    // smoothing above cannot inflate it.
+    let near: f32 = (-2i32..=2)
+        .map(|d| hist[(peak as i32 + d).rem_euclid(BINS as i32) as usize])
+        .sum();
+    if near / total < MIN_COHERENCE {
+        return None;
+    }
+
+    // Sub-bin angle: circular mean over the peak neighbourhood in double-angle space
+    // (which keeps 0 and π identified, exactly the mod-π symmetry of orientations).
+    let (mut sx, mut sy) = (0.0f64, 0.0f64);
+    for d in -2i32..=2 {
+        let i = (peak as i32 + d).rem_euclid(BINS as i32) as usize;
+        let centre = (i as f64 + 0.5) / BINS as f64 * core::f64::consts::PI;
+        sx += f64::from(hist[i]) * (2.0 * centre).cos();
+        sy += f64::from(hist[i]) * (2.0 * centre).sin();
+    }
+    if sx == 0.0 && sy == 0.0 {
+        return None;
+    }
+    let mut angle = (sy.atan2(sx) / 2.0) as f32; // (-π/2, π/2]
+    if angle <= -core::f32::consts::FRAC_PI_2 {
+        angle += core::f32::consts::PI;
+    }
+    Some(angle)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::image::GrayImage;
+
+    /// Bars of period 8 px perpendicular to `angle` (so the *reading* axis is `angle`),
+    /// with soft (tanh-profile, ~1 px) edges. A camera never delivers hard staircase
+    /// edges — real optics blur every transition — and aliased steps would put
+    /// spurious diagonal energy into the gradient histogram that no real capture has.
+    fn bars(angle: f32) -> GrayImage {
+        let (s, c) = angle.sin_cos();
+        let mut img = GrayImage::new(128, 128);
+        for y in 0..128 {
+            for x in 0..128 {
+                // Position along the reading axis, phase within the 2-bar period.
+                let t = c * x as f32 + s * y as f32;
+                let ph = (t / 8.0).rem_euclid(2.0);
+                // Distance (px) to the nearest bar edge; dark half is ph < 1.
+                let d = ph.min((1.0 - ph).abs()).min(2.0 - ph) * 8.0;
+                let soft = (d / 1.2).tanh();
+                let side = if ph < 1.0 { -1.0 } else { 1.0 };
+                img.set(x, y, (127.5 + 127.4 * side * soft).round() as u8);
+            }
+        }
+        img
+    }
+
+    #[test]
+    fn recovers_bar_orientation() {
+        for deg in [0.0f32, 20.0, 45.0, 90.0, -30.0, -75.0] {
+            let angle = deg.to_radians();
+            let img = bars(angle);
+            let got = dominant_gradient_angle(&img.as_frame())
+                .unwrap_or_else(|| panic!("no orientation for {deg}°"));
+            // Compare modulo π.
+            let mut diff = (got - angle).rem_euclid(core::f32::consts::PI);
+            if diff > core::f32::consts::FRAC_PI_2 {
+                diff = core::f32::consts::PI - diff;
+            }
+            assert!(
+                diff.to_degrees() < 4.0,
+                "angle {deg}°: got {:.1}° (diff {:.1}°)",
+                got.to_degrees(),
+                diff.to_degrees()
+            );
+        }
+    }
+
+    #[test]
+    fn rejects_isotropic_texture() {
+        // A checkerboard has equal horizontal and vertical edge energy.
+        let mut img = GrayImage::filled(96, 96, 255);
+        for y in 0..96 {
+            for x in 0..96 {
+                if (x / 6 + y / 6) % 2 == 0 {
+                    img.set(x, y, 0);
+                }
+            }
+        }
+        assert!(dominant_gradient_angle(&img.as_frame()).is_none());
+    }
+}
@@ -123,15 +123,72 @@ pub fn scan_2d(frame: &crate::image::GrayFrame<'_>) -> Vec<Symbol> {
 /// frame. The EAN/UPC edge reader (width ratios, voted across scanlines) reads curved and
 /// blurred captures the quantized grid cannot; the quantized `scan1d` front-end then feeds
 /// the remaining checksummed linear decoders.
+///
+/// The scanline sweep itself only covers a few degrees around horizontal, but the code's
+/// orientation in the crop is arbitrary: each candidate pattern is also tried mirrored
+/// (an upside-down code scans in reverse), and when the sweep finds nothing the frame's
+/// dominant texture orientation is measured ([`crate::imgproc::orient`]) and the whole
+/// crop is derotated and rescanned — so a 1D code is read at any rotation, not just the
+/// near-horizontal band.
 pub fn scan_1d(frame: &crate::image::GrayFrame<'_>) -> Vec<Symbol> {
+    let scan_opts = crate::scan1d::ScanOptions::default();
+    let found = scan_1d_sweep(frame, &scan_opts);
+    if !found.is_empty() {
+        return found;
+    }
+
+    // Nothing near horizontal. If the crop's texture has one dominant orientation —
+    // the signature of a rotated barcode — derotate the whole crop and rescan. The
+    // sweep already covers ±6°, so only meaningfully rotated codes are worth the
+    // resample.
+    let Some(angle) = crate::imgproc::orient::dominant_gradient_angle(frame) else {
+        return found;
+    };
+    if angle.abs() < MIN_DEROTATE_ANGLE {
+        return found;
+    }
+    let image = to_image(frame);
+    let rotated = crate::transform::rotate(&image, -angle);
+    let mut found = scan_1d_sweep(&rotated.as_frame(), &scan_opts);
+
+    // Map each symbol's outline from derotated coordinates back into the frame.
+    let (s, c) = (-angle).sin_cos();
+    let (cx, cy) = (frame.width() as f32 / 2.0, frame.height() as f32 / 2.0);
+    let (ncx, ncy) = (
+        rotated.width() as f32 / 2.0,
+        rotated.height() as f32 / 2.0,
+    );
+    for sym in &mut found {
+        if let Some(loc) = &mut sym.location {
+            for p in &mut loc.outline.corners {
+                let (dx, dy) = (p.x - ncx, p.y - ncy);
+                p.x = c * dx + s * dy + cx;
+                p.y = -s * dx + c * dy + cy;
+            }
+            loc.rotation = Some(loc.rotation.unwrap_or(0.0) + angle);
+        }
+    }
+    found
+}
+
+/// Smallest texture rotation (radians) worth a derotate-and-rescan; the plain sweep
+/// already covers a ±6° band around horizontal.
+const MIN_DEROTATE_ANGLE: f32 = 8.0 * core::f32::consts::PI / 180.0;
+
+/// One near-horizontal 1D pass: the EAN/UPC edge reader plus the quantized `scan1d`
+/// front-end feeding every checksummed linear decoder, each candidate tried in both
+/// reading directions.
+fn scan_1d_sweep(
+    frame: &crate::image::GrayFrame<'_>,
+    scan_opts: &crate::scan1d::ScanOptions,
+) -> Vec<Symbol> {
     use crate::traits::Decode;
 
     let mut found: Vec<Symbol> = Vec::new();
-    let scan_opts = crate::scan1d::ScanOptions::default();
-    if let Some(s) = crate::codes::ean::scan(frame, &scan_opts) {
+    if let Some(s) = crate::codes::ean::scan(frame, scan_opts) {
         found.push(s);
     }
-    let candidates = crate::scan1d::scan_lines(frame, &scan_opts);
+    let candidates = crate::scan1d::scan_lines(frame, scan_opts);
     let linear: [Box<dyn Decode>; 6] = [
         Box::new(crate::codes::code128::Code128Decoder::new()),
         Box::new(crate::codes::ean::EanDecoder::new()),
@@ -141,15 +198,34 @@ pub fn scan_1d(frame: &crate::image::GrayFrame<'_>) -> Vec<Symbol> {
         Box::new(crate::codes::codabar::CodabarDecoder::new()),
     ];
     for cand in &candidates {
+        // A scanline as easily runs against the code's reading direction as with it
+        // (and a 180°-rotated code always does): try the mirrored pattern too. The
+        // decoders are all checksummed, so a mirrored misread cannot false-accept.
+        let mut mirrored = cand.clone();
+        mirrored.pattern.modules.reverse();
+        mirrored.edges.clear();
         for dec in &linear {
             if let Some(s) = crate::scan1d::try_decode(cand, dec.as_ref()) {
                 dedup_push(&mut found, s);
             }
+            if let Some(s) = crate::scan1d::try_decode(&mirrored, dec.as_ref()) {
+                dedup_push(&mut found, s);
+            }
         }
     }
     found
 }
 
+/// Copy a borrowed frame into an owned [`crate::image::GrayImage`] (for resampling).
+fn to_image(frame: &crate::image::GrayFrame<'_>) -> crate::image::GrayImage {
+    let (w, h) = (frame.width(), frame.height());
+    let mut data = Vec::with_capacity(w * h);
+    for y in 0..h {
+        data.extend_from_slice(frame.row(y).expect("row in range"));
+    }
+    crate::image::GrayImage::from_raw(w, h, data)
+}
+
 /// Push `sym` unless an equal `(symbology, text)` is already present.
 fn dedup_push(found: &mut Vec<Symbol>, sym: Symbol) {
     let key = (sym.symbology, sym.text().unwrap_or_default());
 
@@ -37,8 +37,12 @@
 //! - **Blur.** Mild defocus (separable box blur up to a few pixels radius) — edges
 //!   are recovered from midpoint crossings which are blur-stable.
 //! - **Rotation.** A few degrees, handled by scanning at several small angles
-//!   (default ±`MAX_ANGLE_DEG`). Full rotation invariance is **out of scope**: a
-//!   scan line must cross all bars, so near-perpendicular capture is assumed.
+//!   (default ±`MAX_ANGLE_DEG`). Full rotation invariance is deliberately **not**
+//!   this module's job: a scan line must cross all bars, so near-perpendicular
+//!   capture is assumed here. [`crate::pipeline::scan_1d`] supplies it instead, by
+//!   trying every candidate pattern mirrored (180°) and — when the sweep finds
+//!   nothing — measuring the crop's dominant texture orientation and derotating the
+//!   whole crop before rescanning (any other angle).
 //! - **Framing.** The barcode need not span the full frame width, but a light
 //!   quiet zone must be present on both sides of the scan line.
 //!