V0.4.0加入锁定二维码

This commit is contained in:
zhy
2026-08-10 17:09:30 +08:00
parent d885259e2b
commit 241e22abea
34 changed files with 1754 additions and 985 deletions
+21 -77
View File
@@ -1,60 +1,22 @@
use anyhow::{Context, Result};
use eframe::egui::ColorImage;
use qrcode::{types::Color, EcLevel, QrCode};
use rayon::prelude::*;
const QUIET_MODULES: usize = 4;
/// Render exact black/white pixels with an explicit quiet zone.
pub fn render_qr(text: &str, scale: usize) -> Result<ColorImage> {
/// Active optical renderer. QFT2/Base45 text uses only QR alphanumeric
/// characters, allowing the QR encoder to choose a compact alphanumeric data
/// mode. Exact integer module pixels + full quiet zone maximize camera clarity.
pub fn render_qr_fitted(text: &str, target_side: usize) -> Result<ColorImage> {
let code = QrCode::with_error_correction_level(text.as_bytes(), EcLevel::L)
.context("QR payload too large")?;
let modules = code.width();
let scale = scale.max(1);
let side_modules = modules + QUIET_MODULES * 2;
let side_px = side_modules * scale;
let gray = render_code_gray(&code, side_px);
Ok(ColorImage::from_gray([side_px, side_px], &gray))
let modules = code.width() + QUIET_MODULES * 2;
let scale = (target_side / modules).max(1);
let side = modules * scale;
Ok(ColorImage::from_gray([side, side], &render_code_gray(&code, side)))
}
/// Render 1..=4 independent QR symbols into one fixed-size optical page.
/// A 2x2 page quadruples the number of logical QFT frames presented per
/// display refresh while keeping every symbol standards-compliant.
pub fn render_qr_grid(texts: &[String], canvas_side: usize) -> Result<ColorImage> {
let count = texts.len().clamp(1, 4);
if count == 1 {
return render_qr_fitted(&texts[0], canvas_side.max(320));
}
let canvas_side = canvas_side.max(640);
let gutter = (canvas_side / 64).clamp(12, 24);
let cell = (canvas_side - gutter * 3) / 2;
let rendered: Vec<(usize, Vec<u8>)> = texts[..count]
.par_iter()
.map(|text| render_qr_gray_fitted(text, cell))
.collect::<Result<Vec<_>>>()?;
let mut canvas = vec![255u8; canvas_side * canvas_side];
for (index, (side, gray)) in rendered.into_iter().enumerate() {
let col = index % 2;
let row = index / 2;
let cell_x = gutter + col * (cell + gutter);
let cell_y = gutter + row * (cell + gutter);
let x0 = cell_x + (cell.saturating_sub(side)) / 2;
let y0 = cell_y + (cell.saturating_sub(side)) / 2;
for y in 0..side {
let dst = (y0 + y) * canvas_side + x0;
let src = y * side;
canvas[dst..dst + side].copy_from_slice(&gray[src..src + side]);
}
}
Ok(ColorImage::from_gray([canvas_side, canvas_side], &canvas))
}
/// Pairing QR favors scan reliability over maximum capacity. QFTPAIR2 is kept
/// deliberately short, so medium error correction still yields a low-version
/// symbol that phones acquire faster at imperfect angles.
/// Pairing QR stays static and uses M error correction for first-scan reliability.
pub fn render_pair_qr(text: &str, target_side: usize) -> Result<ColorImage> {
let code = QrCode::with_error_correction_level(text.as_bytes(), EcLevel::M)
.context("pair QR payload too large")?;
@@ -64,38 +26,20 @@ pub fn render_pair_qr(text: &str, target_side: usize) -> Result<ColorImage> {
Ok(ColorImage::from_gray([side, side], &render_code_gray(&code, side)))
}
pub fn render_qr_fitted(text: &str, target_side: usize) -> Result<ColorImage> {
let (side, gray) = render_qr_gray_fitted(text, target_side)?;
Ok(ColorImage::from_gray([side, side], &gray))
}
fn render_qr_gray_fitted(text: &str, target_side: usize) -> Result<(usize, Vec<u8>)> {
let code = QrCode::with_error_correction_level(text.as_bytes(), EcLevel::L)
.context("QR payload too large")?;
let modules = code.width() + QUIET_MODULES * 2;
let scale = (target_side / modules).max(1);
let side = modules * scale;
Ok((side, render_code_gray(&code, side)))
}
fn render_code_gray(code: &QrCode, side_px: usize) -> Vec<u8> {
let modules = code.width();
let side_modules = modules + QUIET_MODULES * 2;
let scale = (side_px / side_modules).max(1);
let actual_side = side_modules * scale;
fn render_code_gray(code: &QrCode, side: usize) -> Vec<u8> {
let qr_width = code.width();
let modules = qr_width + QUIET_MODULES * 2;
let scale = (side / modules).max(1);
let actual_side = modules * scale;
let mut gray = vec![255u8; actual_side * actual_side];
let colors = code.to_colors();
for y in 0..modules {
for x in 0..modules {
if colors[y * modules + x] != Color::Dark {
continue;
}
let x0 = (x + QUIET_MODULES) * scale;
let y0 = (y + QUIET_MODULES) * scale;
for py in y0..y0 + scale {
for y in 0..qr_width {
for x in 0..qr_width {
if code[(x, y)] != Color::Dark { continue; }
let px0 = (x + QUIET_MODULES) * scale;
let py0 = (y + QUIET_MODULES) * scale;
for py in py0..py0 + scale {
let row = py * actual_side;
gray[row + x0..row + x0 + scale].fill(0);
gray[row + px0..row + px0 + scale].fill(0);
}
}
}