use image::{GrayImage, Luma}; use crate::dsl::{BarcodeSymbology, QrEcc}; #[derive(Debug)] pub enum RasterError { Encode(String), Image(String), } impl std::fmt::Display for RasterError { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { Self::Encode(msg) | Self::Image(msg) => write!(f, "{msg}"), } } } impl std::error::Error for RasterError {} pub fn render_barcode( symbology: BarcodeSymbology, data: &str, height: u32, ) -> Result { use barcoders::generators::image::Image as BarcodeImage; use barcoders::sym::codabar::Codabar; use barcoders::sym::code11::Code11; use barcoders::sym::code128::Code128; use barcoders::sym::code39::Code39; use barcoders::sym::code93::Code93; use barcoders::sym::ean13::UPCA; use barcoders::sym::ean13::EAN13; use barcoders::sym::ean8::EAN8; use barcoders::sym::tf::TF; let data = data.trim(); if data.is_empty() { return Err(RasterError::Encode("Barcode data is empty".into())); } let encoded = match symbology { BarcodeSymbology::Code128 => { Code128::new(code128_barcoders_input(data)) .map_err(|e| RasterError::Encode(e.to_string()))? .encode() } BarcodeSymbology::Code39 => Code39::new(data) .map_err(|e| RasterError::Encode(e.to_string()))? .encode(), BarcodeSymbology::Code93 => Code93::new(data) .map_err(|e| RasterError::Encode(e.to_string()))? .encode(), BarcodeSymbology::Ean13 => EAN13::new(data) .map_err(|e| RasterError::Encode(e.to_string()))? .encode(), BarcodeSymbology::Ean8 => EAN8::new(data) .map_err(|e| RasterError::Encode(e.to_string()))? .encode(), BarcodeSymbology::UpcA => UPCA::new(data) .map_err(|e| RasterError::Encode(e.to_string()))? .encode(), BarcodeSymbology::UpcE => { return Err(RasterError::Encode( "UPC-E raster is not supported; use native UPC-E".into(), )); } BarcodeSymbology::Itf => TF::interleaved(data) .map_err(|e| RasterError::Encode(e.to_string()))? .encode(), BarcodeSymbology::Codabar => Codabar::new(data) .map_err(|e| RasterError::Encode(e.to_string()))? .encode(), BarcodeSymbology::Code11 => Code11::new(data) .map_err(|e| RasterError::Encode(e.to_string()))? .encode(), }; let png = BarcodeImage::png(height); let bytes = png .generate(&encoded) .map_err(|e| RasterError::Image(e.to_string()))?; let img = image::load_from_memory(&bytes).map_err(|e| RasterError::Image(e.to_string()))?; Ok(img.to_luma8()) } /// Stretch a barcode to exactly `target_width` dots, keeping the original height. /// /// Barcodes are widened to the full printable width so module bars stay /// wide enough to scan reliably. pub fn scale_gray_to_print_width(gray: GrayImage, target_width: u32) -> GrayImage { let (w, h) = gray.dimensions(); if w == 0 || h == 0 || target_width == 0 { return gray; } if w == target_width { return gray; } image::imageops::resize( &gray, target_width, h, image::imageops::FilterType::Nearest, ) } /// Prefix payload for `barcoders` Code128. /// /// The crate requires a leading charset marker. Set A (`\u{00C0}`) only supports /// uppercase letters; mixed-case and typical URLs need set B (`\u{0181}`). fn code128_barcoders_input(data: &str) -> String { let start = if data.chars().any(|c| c.is_ascii_lowercase()) { '\u{0181}' // Start B — upper + lower case } else { '\u{00C0}' // Start A — uppercase, digits, symbols }; format!("{start}{data}") } pub fn render_qr( data: &str, version: Option, ecc: QrEcc, module_pixels: u32, ) -> Result { use qrcode::EcLevel; use qrcode::QrCode; use qrcode::Version; let ec = match ecc { QrEcc::L => EcLevel::L, QrEcc::M => EcLevel::M, QrEcc::Q => EcLevel::Q, QrEcc::H => EcLevel::H, }; let code = if let Some(v) = version { let v = v.clamp(1, 40); QrCode::with_version(data.as_bytes(), Version::Normal(i16::from(v)), ec) .map_err(|e| RasterError::Encode(e.to_string()))? } else { QrCode::with_error_correction_level(data.as_bytes(), ec) .map_err(|e| RasterError::Encode(e.to_string()))? }; let width = code.width() as u32; let scale = module_pixels.max(1); let out_w = width * scale; let mut img = GrayImage::new(out_w, out_w); for y in 0..width { for x in 0..width { let dark = code[(x as usize, y as usize)] == qrcode::Color::Dark; let color = if dark { 0 } else { 255 }; for dy in 0..scale { for dx in 0..scale { img.put_pixel(x * scale + dx, y * scale + dy, Luma([color])); } } } } Ok(img) } #[cfg(test)] mod tests { use super::*; #[test] fn barcode_stretches_to_print_width() { let narrow = render_barcode(BarcodeSymbology::Code128, "X", 60).unwrap(); assert!(narrow.width() < 384); let original_h = narrow.height(); let wide = scale_gray_to_print_width(narrow, 384); assert_eq!(wide.width(), 384); assert_eq!(wide.height(), original_h); } #[test] fn renders_code128_raster() { let img = render_barcode(BarcodeSymbology::Code128, "TEST123", 60).unwrap(); assert!(img.width() > 10); assert_eq!(img.height(), 60); } #[test] fn renders_code128_mixed_case() { let img = render_barcode(BarcodeSymbology::Code128, "Testcode", 60).unwrap(); assert!(img.width() > 10); assert_eq!(img.height(), 60); } #[test] fn code128_accepts_url_like_data() { let img = render_barcode(BarcodeSymbology::Code128, "https://example.com", 60).unwrap(); assert!(img.width() > 10); } #[test] fn code128_rejects_empty_data() { let err = render_barcode(BarcodeSymbology::Code128, " ", 60).unwrap_err(); assert!(err.to_string().contains("empty")); } #[test] fn renders_qr_raster_with_version() { let img = render_qr("https://example.com", Some(5), QrEcc::M, 4).unwrap(); assert!(img.width() >= 20); } }