bc-mur 0.1.0

Multipart UR QR code generator — single-frame and animated fountain-coded QR sequences with optional logo overlay.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

use std::path::PathBuf;

use anyhow::Result;
use bc_mur::{
    AnimateParams, Color, CorrectionLevel, DEFAULT_MAX_MODULES, Logo,
    LogoClearShape,
};
use clap::Args;

use crate::exec::Exec;

/// Dump multipart QR frames as numbered PNGs.
#[derive(Debug, Args)]
pub struct CommandArgs {
    /// UR string to encode, or `-` to read from stdin.
    pub ur_string: String,

    /// Output directory for numbered PNGs.
    #[arg(short, long)]
    pub output: PathBuf,

    /// Image size in pixels.
    #[arg(short, long, default_value = "512")]
    pub size: u32,

    /// Foreground color (hex).
    #[arg(long, default_value = "#000000")]
    pub fg: String,

    /// Background color (hex).
    #[arg(long, default_value = "#FFFFFF")]
    pub bg: String,

    /// Path to SVG logo file.
    #[arg(long)]
    pub logo: Option<PathBuf>,

    /// Logo fraction of QR width (0.01–0.99).
    #[arg(long, default_value = "0.25")]
    pub logo_fraction: f64,

    /// Logo clear border in modules (0–5).
    #[arg(long, default_value = "1")]
    pub logo_border: usize,

    /// Logo clear shape (square or circle).
    #[arg(long, default_value = "square")]
    pub logo_shape: String,

    /// Error correction level (low, medium, quartile, high).
    #[arg(short, long)]
    pub correction: Option<String>,

    /// Quiet zone modules around the QR code.
    #[arg(long, default_value = "1")]
    pub quiet_zone: u32,

    /// Dark mode (white-on-black).
    #[arg(long, default_value = "false")]
    pub dark: bool,

    /// Maximum fragment length for fountain coding.
    #[arg(long, default_value = "100")]
    pub max_fragment_len: usize,

    /// Frames per second (affects cycle count).
    #[arg(long, default_value = "8")]
    pub fps: f64,

    /// Number of complete cycles through all fragments.
    #[arg(long, default_value = "3")]
    pub cycles: u32,

    /// Exact number of frames (overrides --cycles).
    #[arg(long)]
    pub frame_count: Option<usize>,

    /// Maximum QR module count for reliable scanning.
    #[arg(long, default_value_t = DEFAULT_MAX_MODULES)]
    pub max_modules: usize,

    /// Disable the QR density check.
    #[arg(long, default_value = "false")]
    pub no_density_check: bool,
}

impl Exec for CommandArgs {
    fn exec(&self) -> Result<String> {
        let ur_string = super::single::read_input(&self.ur_string)?;
        let (fg, bg) = if self.dark {
            (Color::from_hex(&self.bg)?, Color::from_hex(&self.fg)?)
        } else {
            (Color::from_hex(&self.fg)?, Color::from_hex(&self.bg)?)
        };

        let logo = if let Some(path) = &self.logo {
            let svg_data = std::fs::read(path)?;
            let shape: LogoClearShape = self
                .logo_shape
                .parse()
                .map_err(|e: String| anyhow::anyhow!(e))?;
            Some(Logo::from_svg(
                &svg_data,
                self.logo_fraction,
                self.logo_border,
                shape,
            )?)
        } else {
            None
        };

        let correction = self
            .correction
            .as_ref()
            .map(|s| {
                s.parse::<CorrectionLevel>().map_err(|e| anyhow::anyhow!(e))
            })
            .transpose()?;

        let ur = bc_ur::UR::from_ur_string(&ur_string)?;

        let params = AnimateParams {
            max_fragment_len: self.max_fragment_len,
            correction,
            size: self.size,
            foreground: fg,
            background: bg,
            quiet_zone: self.quiet_zone,
            logo,
            fps: self.fps,
            cycles: self.cycles,
            frame_count: self.frame_count,
            max_modules: if self.no_density_check {
                None
            } else {
                Some(self.max_modules)
            },
        };

        let frames = bc_mur::generate_frames(&ur, &params)?;
        bc_mur::write_frame_pngs(&frames, &self.output)?;

        Ok(format!(
            "Wrote {} frames to {}",
            frames.len(),
            self.output.display()
        ))
    }
}