imprimatur 0.3.0 → 0.5.0

data/ext/imprimatur_native/core/src/barcode/ean.rs

@@ -0,0 +1,91 @@
+//! EAN-13, EAN-8 and UPC-A (ISO/IEC 15420): GTINs as retail scanners read
+//! them, digits in seven-module patterns between guard bars.
+
+use super::Symbology;
+use super::gs1::check_digit;
+use crate::Result;
+
+/// The left-hand, odd-parity patterns (set A) of 0 to 9. The right-hand
+/// patterns (set C) are their inverses; the even-parity ones (set B), the
+/// right-hand ones mirrored.
+const SET_A: [u8; 10] = [
+    0b000_1101, 0b001_1001, 0b001_0011, 0b011_1101, 0b010_0011, 0b011_0001, 0b010_1111, 0b011_1011,
+    0b011_0111, 0b000_1011,
+];
+/// Which of EAN-13's left six digits take set B, the first in the high
+/// bit, by its leading digit (the one no pattern draws).
+const PARITY: [u8; 10] = [
+    0b00_0000, 0b00_1011, 0b00_1101, 0b00_1110, 0b01_0011, 0b01_1001, 0b01_1100, 0b01_0101,
+    0b01_0110, 0b01_1010,
+];
+const GUARD: [bool; 3] = [true, false, true];
+const CENTER: [bool; 5] = [false, true, false, true, false];
+
+/// `input` as digits: one short of `length` gets its check digit, `length`
+/// must end with the right one.
+pub fn digits(symbology: Symbology, input: &str, length: usize) -> Result<Vec<u8>> {
+    input
+        .bytes()
+        .all(|byte| byte.is_ascii_digit())
+        .ok_or_else(|| symbology.invalid(format!("{input:?} is not all digits")))?;
+    (input.len() == length - 1 || input.len() == length).ok_or_else(|| {
+        let (short, given) = (length - 1, input.len());
+        symbology.invalid(format!(
+            "it takes {short} digits, or {length} with the check digit, not {given}"
+        ))
+    })?;
+    let check = check_digit(&input[..length - 1]).unwrap_or_default();
+    let mut digits: Vec<u8> = input.bytes().map(|byte| byte - b'0').collect();
+    match digits.get(length - 1) {
+        None => digits.push(check),
+        Some(&last) if last != check => {
+            return Err(symbology.invalid(format!("{input} has check digit {last}, not {check}")));
+        }
+        Some(_) => {}
+    }
+    Ok(digits)
+}
+
+pub fn text(digits: &[u8]) -> String {
+    digits.iter().map(|digit| char::from(b'0' + digit)).collect()
+}
+
+/// 95 modules: guard, six left digits by the first's parity, center, six
+/// right digits, guard.
+pub fn ean13(digits: &[u8]) -> Vec<bool> {
+    let parity = PARITY[usize::from(digits[0])];
+    let mut modules = Vec::with_capacity(95);
+    modules.extend(GUARD);
+    for (index, &digit) in digits[1..7].iter().enumerate() {
+        let even = (parity >> (5 - index)) & 1 == 1;
+        push(&mut modules, if even { set_b(digit) } else { SET_A[usize::from(digit)] });
+    }
+    modules.extend(CENTER);
+    digits[7..].iter().for_each(|&digit| push(&mut modules, set_c(digit)));
+    modules.extend(GUARD);
+    modules
+}
+
+/// 67 modules: guard, four digits in set A, center, four in set C, guard.
+pub fn ean8(digits: &[u8]) -> Vec<bool> {
+    let mut modules = Vec::with_capacity(67);
+    modules.extend(GUARD);
+    digits[..4].iter().for_each(|&digit| push(&mut modules, SET_A[usize::from(digit)]));
+    modules.extend(CENTER);
+    digits[4..].iter().for_each(|&digit| push(&mut modules, set_c(digit)));
+    modules.extend(GUARD);
+    modules
+}
+
+const fn set_c(digit: u8) -> u8 {
+    !SET_A[digit as usize] & 0x7F
+}
+
+const fn set_b(digit: u8) -> u8 {
+    set_c(digit).reverse_bits() >> 1
+}
+
+/// A seven-module pattern, its high bit first.
+fn push(modules: &mut Vec<bool>, pattern: u8) {
+    modules.extend((0..7).rev().map(|bit| (pattern >> bit) & 1 == 1));
+}

data/ext/imprimatur_native/core/src/barcode/gs1.rs

@@ -0,0 +1,188 @@
+//! GS1 element strings as people write them, `(01)09506000134352(10)AB12`:
+//! Application Identifiers in parentheses, each followed by its value.
+
+#[cfg(test)]
+mod tests;
+
+use crate::{Error, Result};
+
+/// What a symbol carries: characters, and FNC1, which ends every
+/// variable-length field but the last.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Unit {
+    Char(u8),
+    Fnc1,
+}
+
+/// One Application Identifier and its value.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Field<'a> {
+    pub ai: &'a str,
+    pub value: &'a str,
+}
+
+/// Element strings whose length, AI included, the AI's first two digits
+/// fix (GS1 General Specifications, figure 7.8.5-2). All are numeric; the
+/// rest end with FNC1 unless last.
+const PREDEFINED: [(&str, usize); 22] = [
+    ("00", 20),
+    ("01", 16),
+    ("02", 16),
+    ("03", 16),
+    ("04", 18),
+    ("11", 8),
+    ("12", 8),
+    ("13", 8),
+    ("14", 8),
+    ("15", 8),
+    ("16", 8),
+    ("17", 8),
+    ("18", 8),
+    ("19", 8),
+    ("20", 4),
+    ("31", 10),
+    ("32", 10),
+    ("33", 10),
+    ("34", 10),
+    ("35", 10),
+    ("36", 10),
+    ("41", 16),
+];
+
+/// The longest value any AI takes.
+const MAX_VALUE: usize = 90;
+
+/// The GS1 check digit (modulo 10, weights 3 and 1 from the right) of
+/// `digits`, as GTINs, SSCCs and GLNs end with; `None` unless all are
+/// digits.
+///
+/// ```
+/// assert_eq!(imprimatur::barcode::check_digit("950600013435"), Some(2));
+/// ```
+#[must_use]
+pub fn check_digit(digits: &str) -> Option<u8> {
+    let mut sum = 0_u32;
+    for (index, byte) in digits.bytes().rev().enumerate() {
+        byte.is_ascii_digit().then_some(())?;
+        let weight = if index % 2 == 0 { 3 } else { 1 };
+        sum += weight * u32::from(byte - b'0');
+    }
+    u8::try_from((10 - sum % 10) % 10).ok()
+}
+
+/// Reads an element string into its fields.
+///
+/// # Errors
+/// [`Error::InvalidElementString`] for anything but AIs of 2 to 4 digits in
+/// parentheses, each with a value in GS1's character set, of the length
+/// and check digit its AI takes.
+pub fn parse(input: &str) -> Result<Vec<Field<'_>>> {
+    let invalid = |reason: String| Error::InvalidElementString(reason);
+    let bytes = input.as_bytes();
+    (!bytes.is_empty()).ok_or_else(|| invalid("it is empty".to_owned()))?;
+    let mut fields = Vec::new();
+    let mut at = 0;
+    while at < bytes.len() {
+        let length = ai_at(bytes, at).ok_or_else(|| {
+            invalid(format!("expected an AI such as (01) at character {}", at + 1))
+        })?;
+        let start = at + length + 2;
+        let end = (start..bytes.len()).find(|&next| ai_at(bytes, next).is_some());
+        let end = end.unwrap_or(bytes.len());
+        let field = Field { ai: &input[at + 1..at + 1 + length], value: &input[start..end] };
+        validate(field)?;
+        fields.push(field);
+        at = end;
+    }
+    Ok(fields)
+}
+
+/// `element_string`, parsed and run together as [`units`] does: what every
+/// encoder needs before laying its symbol out.
+///
+/// # Errors
+/// [`Error::InvalidElementString`], as [`parse`].
+pub fn element_units(element_string: &str) -> Result<Vec<Unit>> {
+    Ok(units(&parse(element_string)?))
+}
+
+/// The fields run together: no parentheses, FNC1 after each field of
+/// variable length but the last.
+pub fn units(fields: &[Field<'_>]) -> Vec<Unit> {
+    let mut units = Vec::new();
+    for (index, field) in fields.iter().enumerate() {
+        units.extend(field.ai.bytes().chain(field.value.bytes()).map(Unit::Char));
+        if predefined(field.ai).is_none() && index + 1 < fields.len() {
+            units.push(Unit::Fnc1);
+        }
+    }
+    units
+}
+
+/// The length of the AI in parentheses at `at`: 2 to 4 digits.
+fn ai_at(bytes: &[u8], at: usize) -> Option<usize> {
+    (bytes.get(at) == Some(&b'(')).then_some(())?;
+    let digits = bytes[at + 1..].iter().take_while(|byte| byte.is_ascii_digit()).count();
+    ((2..=4).contains(&digits) && bytes.get(at + 1 + digits) == Some(&b')')).then_some(digits)
+}
+
+/// The length of the element string, AI included, when the AI fixes it.
+fn predefined(ai: &str) -> Option<usize> {
+    PREDEFINED.iter().find(|(prefix, _)| ai.starts_with(prefix)).map(|&(_, length)| length)
+}
+
+fn validate(field: Field<'_>) -> Result<()> {
+    let Field { ai, value } = field;
+    let invalid = |reason: String| Err(Error::InvalidElementString(format!("({ai}) {reason}")));
+    if value.is_empty() {
+        return invalid("has no value".to_owned());
+    }
+    let outside = |character: char| !u8::try_from(character).is_ok_and(in_character_set);
+    if let Some(character) = value.chars().find(|&character| outside(character)) {
+        return invalid(format!("holds {character:?}, outside GS1's character set"));
+    }
+    if value.len() > MAX_VALUE {
+        return invalid(format!("holds {} characters, more than {MAX_VALUE}", value.len()));
+    }
+    let Some(length) = predefined(ai) else { return Ok(()) };
+    let digits = length - ai.len();
+    if value.len() != digits || !value.bytes().all(|byte| byte.is_ascii_digit()) {
+        return invalid(format!("takes {digits} digits, not {value:?}"));
+    }
+    // SSCC, GTINs and GLNs end with a check digit.
+    let checked = matches!(ai, "00" | "01" | "02") || ai.starts_with("41");
+    let (body, last) = value.split_at(value.len() - 1);
+    let expected = check_digit(body).unwrap_or(0);
+    if checked && last.as_bytes()[0] - b'0' != expected {
+        return invalid(format!("{value} has check digit {last}, not {expected}"));
+    }
+    Ok(())
+}
+
+/// GS1 AI encodable character set 82: letters, digits and
+/// ``!"%&'()*+,-./:;<=>?_``.
+const fn in_character_set(byte: u8) -> bool {
+    byte.is_ascii_alphanumeric()
+        || matches!(
+            byte,
+            b'!' | b'"'
+                | b'%'
+                | b'&'
+                | b'\''
+                | b'('
+                | b')'
+                | b'*'
+                | b'+'
+                | b','
+                | b'-'
+                | b'.'
+                | b'/'
+                | b':'
+                | b';'
+                | b'<'
+                | b'='
+                | b'>'
+                | b'?'
+                | b'_'
+        )
+}

data/ext/imprimatur_native/core/src/barcode/matrix.rs

@@ -0,0 +1,130 @@
+//! QR Code and Data Matrix, through the `qrcode` and `datamatrix` crates.
+
+use datamatrix::{DataMatrix, SymbolList};
+use qrcode::bits::Bits;
+use qrcode::{Color, EcLevel, QrCode, QrResult, Version};
+
+use super::Symbology;
+use super::gs1::Unit;
+use crate::Result;
+
+/// How much of a QR Code may be damaged and still read: about 7%, 15%, 25%
+/// or 30% of it.
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash)]
+pub enum Level {
+    Low,
+    #[default]
+    Medium,
+    Quartile,
+    High,
+}
+
+impl From<Level> for EcLevel {
+    fn from(level: Level) -> Self {
+        match level {
+            Level::Low => Self::L,
+            Level::Medium => Self::M,
+            Level::Quartile => Self::Q,
+            Level::High => Self::H,
+        }
+    }
+}
+
+/// Where FNC1 separates fields, GS1 symbols carry `GS` (ASCII 29), which
+/// is also what scanners transmit for it.
+const GS: u8 = 0x1D;
+/// Digits shorter than this stay in byte mode: switching to numeric mode
+/// and back costs more than it saves.
+const NUMERIC_RUN: usize = 6;
+
+/// A QR Code's side in modules and its modules, row by row.
+pub fn qr(data: &[u8], level: Level) -> Result<(usize, Vec<bool>)> {
+    let code = QrCode::with_error_correction_level(data, level.into())
+        .map_err(|_| too_long(Symbology::QrCode))?;
+    Ok(qr_modules(code))
+}
+
+/// A GS1 QR Code (FNC1 in first position) in the smallest version it fits.
+pub fn gs1_qr(units: &[Unit], level: Level) -> Result<(usize, Vec<bool>)> {
+    let level = EcLevel::from(level);
+    let data = bytes(units);
+    let bits = (1..=40)
+        .find_map(|version| gs1_bits(&data, Version::Normal(version), level).ok())
+        .ok_or_else(|| too_long(Symbology::QrCode))?;
+    let code = QrCode::with_bits(bits, level).map_err(|_| too_long(Symbology::QrCode))?;
+    Ok(qr_modules(code))
+}
+
+/// Long runs of digits in numeric mode, the rest in byte mode: alphanumeric
+/// mode would read a `%` in the data as a separator.
+fn gs1_bits(data: &[u8], version: Version, level: EcLevel) -> QrResult<Bits> {
+    let mut bits = Bits::new(version);
+    bits.push_fnc1_first_position()?;
+    let mut rest = data;
+    while !rest.is_empty() {
+        let digits = rest.iter().take_while(|byte| byte.is_ascii_digit()).count();
+        if digits >= NUMERIC_RUN {
+            bits.push_numeric_data(&rest[..digits])?;
+            rest = &rest[digits..];
+            continue;
+        }
+        let mut end = 0;
+        while end < rest.len() {
+            let run = rest[end..].iter().take_while(|byte| byte.is_ascii_digit()).count();
+            if run >= NUMERIC_RUN {
+                break;
+            }
+            end += run.max(1);
+        }
+        bits.push_byte_data(&rest[..end])?;
+        rest = &rest[end..];
+    }
+    bits.push_terminator(level)?;
+    Ok(bits)
+}
+
+/// A square Data Matrix's columns and rows, and its modules row by row.
+pub fn data_matrix(text: &str) -> Result<((usize, usize), Vec<bool>)> {
+    let code =
+        DataMatrix::encode_str(text, square()).map_err(|_| too_long(Symbology::DataMatrix))?;
+    Ok(modules(&code))
+}
+
+/// A square GS1 `DataMatrix`: FNC1 first, then the data.
+pub fn gs1_data_matrix(units: &[Unit]) -> Result<((usize, usize), Vec<bool>)> {
+    let code = DataMatrix::encode_gs1(&bytes(units), square())
+        .map_err(|_| too_long(Symbology::DataMatrix))?;
+    Ok(modules(&code))
+}
+
+fn qr_modules(code: QrCode) -> (usize, Vec<bool>) {
+    (code.width(), code.into_colors().into_iter().map(|color| color == Color::Dark).collect())
+}
+
+fn square() -> SymbolList {
+    SymbolList::default().enforce_square()
+}
+
+fn modules(code: &DataMatrix) -> ((usize, usize), Vec<bool>) {
+    let bitmap = code.bitmap();
+    let (columns, rows) = (bitmap.width(), bitmap.height());
+    let mut modules = vec![false; columns * rows];
+    for (x, y) in bitmap.pixels() {
+        modules[y * columns + x] = true;
+    }
+    ((columns, rows), modules)
+}
+
+fn bytes(units: &[Unit]) -> Vec<u8> {
+    units
+        .iter()
+        .map(|unit| match unit {
+            Unit::Char(byte) => *byte,
+            Unit::Fnc1 => GS,
+        })
+        .collect()
+}
+
+fn too_long(symbology: Symbology) -> crate::Error {
+    symbology.invalid("too much data for the largest symbol")
+}