feat: 自动抠出阻焊区域

Author: HalfSweet

src/colorful/encrypt.rs

@@ -0,0 +1,70 @@
+use aes_gcm::aead::generic_array::{typenum::U16, GenericArray};
+use aes_gcm::{
+    aead::{Aead, KeyInit},
+    aes::Aes128,
+    AesGcm,
+};
+use anyhow::{anyhow, Context, Result};
+use rand::{rngs::OsRng, RngCore};
+use rsa::pkcs8::DecodePublicKey;
+use rsa::{Oaep, RsaPublicKey};
+use sha2::Sha256;
+use std::fs::File;
+use std::io::Write;
+use std::path::Path;
+
+pub(crate) struct KeyMaterial {
+    aes_key: [u8; 16],
+    aes_iv: [u8; 16],
+    enc_key: Vec<u8>,
+    enc_iv: Vec<u8>,
+}
+
+impl KeyMaterial {
+    pub(crate) fn generate(public_key_pem: &str) -> Result<Self> {
+        let mut aes_key = [0u8; 16];
+        let mut aes_iv = [0u8; 16];
+        OsRng.fill_bytes(&mut aes_key);
+        OsRng.fill_bytes(&mut aes_iv);
+
+        let public_key = RsaPublicKey::from_public_key_pem(public_key_pem)
+            .context("Invalid embedded RSA public key")?;
+        let enc_key = public_key
+            .encrypt(&mut OsRng, Oaep::new::<Sha256>(), &aes_key)
+            .context("Encrypt AES key")?;
+        let enc_iv = public_key
+            .encrypt(&mut OsRng, Oaep::new::<Sha256>(), &aes_iv)
+            .context("Encrypt AES IV")?;
+
+        Ok(Self {
+            aes_key,
+            aes_iv,
+            enc_key,
+            enc_iv,
+        })
+    }
+}
+
+pub(crate) fn encrypt_and_write(
+    svg: &str,
+    key_material: &KeyMaterial,
+    output: &Path,
+) -> Result<()> {
+    // AES-128-GCM with 16-byte nonce to mirror the original script (WebCrypto)
+    type Aes128Gcm16 = AesGcm<Aes128, U16>;
+    let cipher = Aes128Gcm16::new_from_slice(&key_material.aes_key).context("Create AES cipher")?;
+    let nonce = GenericArray::<u8, U16>::from_slice(&key_material.aes_iv);
+    let ciphertext = cipher
+        .encrypt(nonce, svg.as_bytes())
+        .map_err(|e| anyhow!("Encrypt silkscreen SVG: {:?}", e))?;
+
+    let mut file = File::create(output).with_context(|| format!("Create {}", output.display()))?;
+    file.write_all(&key_material.enc_key)
+        .with_context(|| format!("Write AES key for {}", output.display()))?;
+    file.write_all(&key_material.enc_iv)
+        .with_context(|| format!("Write AES IV for {}", output.display()))?;
+    file.write_all(&ciphertext)
+        .with_context(|| format!("Write ciphertext for {}", output.display()))?;
+
+    Ok(())
+}

src/colorful/mask.rs

@@ -0,0 +1,187 @@
+use super::types::{mm_to_mil_10, MaskPaths};
+use anyhow::{anyhow, Result};
+use gerber_parser::{gerber_types::*, parse};
+use std::io::{BufReader, Cursor};
+
+fn coords_to_mm(coords: &Option<Coordinates>, last: (f64, f64), units: Unit) -> (f64, f64) {
+    let mut x = last.0;
+    let mut y = last.1;
+    if let Some(coords) = coords {
+        if let Some(cx) = coords.x {
+            let mut val: f64 = cx.into();
+            if matches!(units, Unit::Inches) {
+                val *= 25.4;
+            }
+            x = val;
+        }
+        if let Some(cy) = coords.y {
+            let mut val: f64 = cy.into();
+            if matches!(units, Unit::Inches) {
+                val *= 25.4;
+            }
+            y = val;
+        }
+    }
+    (x, y)
+}
+
+fn to_svg_space(x_mm: f64, y_mm: f64) -> (f64, f64) {
+    (mm_to_mil_10(x_mm), -mm_to_mil_10(y_mm))
+}
+
+fn rect_path(center: (f64, f64), w_mm: f64, h_mm: f64) -> String {
+    let (cx, cy) = center;
+    let hw = mm_to_mil_10(w_mm) / 2.0;
+    let hh = mm_to_mil_10(h_mm) / 2.0;
+    let x0 = cx - hw;
+    let x1 = cx + hw;
+    let y0 = cy - hh;
+    let y1 = cy + hh;
+    format!("M {x0} {y0} L {x1} {y0} {x1} {y1} {x0} {y1} {x0} {y0} ")
+}
+
+fn path_from_region(points: &[(f64, f64)]) -> Option<String> {
+    if points.is_empty() {
+        return None;
+    }
+    let mut d = String::new();
+    for (idx, (x, y)) in points.iter().enumerate() {
+        if idx == 0 {
+            d.push_str(&format!("M {} {} ", x, y));
+        } else {
+            d.push_str(&format!("L {} {} ", x, y));
+        }
+    }
+    d.push('Z');
+    Some(d)
+}
+
+fn aperture_bbox(ap: &Aperture) -> Option<(f64, f64)> {
+    match ap {
+        Aperture::Circle(c) => Some((c.diameter, c.diameter)),
+        Aperture::Rectangle(r) | Aperture::Obround(r) => Some((r.x, r.y)),
+        Aperture::Macro(name, args) if name == "RoundRect" => {
+            parse_round_rect_macro(args.as_deref())
+        }
+        _ => None,
+    }
+}
+
+fn parse_round_rect_macro(args: Option<&[MacroDecimal]>) -> Option<(f64, f64)> {
+    let args = args?;
+    if args.len() < 3 {
+        return None;
+    }
+    // Skip radius (first value)
+    let coords = &args[1..];
+    let mut xs = Vec::new();
+    let mut ys = Vec::new();
+    for pair in coords.chunks(2) {
+        if pair.len() == 2 {
+            match (&pair[0], &pair[1]) {
+                (MacroDecimal::Value(x), MacroDecimal::Value(y)) => {
+                    xs.push(x);
+                    ys.push(y);
+                }
+                _ => {}
+            }
+        }
+    }
+    if xs.is_empty() || ys.is_empty() {
+        return None;
+    }
+    let w = xs.iter().fold(f64::NEG_INFINITY, |a, &b| a.max(*b))
+        - xs.iter().fold(f64::INFINITY, |a, &b| a.min(*b));
+    let h = ys.iter().fold(f64::NEG_INFINITY, |a, &b| a.max(*b))
+        - ys.iter().fold(f64::INFINITY, |a, &b| a.min(*b));
+    Some((w.abs(), h.abs()))
+}
+
+pub fn parse_solder_mask(content: &str) -> Result<MaskPaths> {
+    let reader = BufReader::new(Cursor::new(content));
+    let doc = match parse(reader) {
+        Ok(doc) => doc,
+        Err((partial, err)) => {
+            if partial.commands().is_empty() {
+                return Err(anyhow!("Failed to parse solder mask: {err}"));
+            }
+            partial
+        }
+    };
+
+    let mut units = doc.units.unwrap_or(Unit::Millimeters);
+    let mut current_aperture: Option<&Aperture> = None;
+    let mut current_pos: (f64, f64) = (0.0, 0.0);
+    let mut region_active = false;
+    let mut region_points: Vec<(f64, f64)> = Vec::new();
+    let mut shapes: MaskPaths = Vec::new();
+    let mut interp_mode = InterpolationMode::Linear;
+
+    let apertures = &doc.apertures;
+
+    for command in doc.commands() {
+        match command {
+            Command::ExtendedCode(ExtendedCode::Unit(u)) => units = *u,
+            Command::FunctionCode(FunctionCode::GCode(g)) => match g {
+                GCode::InterpolationMode(m) => interp_mode = *m,
+                GCode::RegionMode(on) => {
+                    if !on && region_active && region_points.len() > 1 {
+                        if let Some(d) = path_from_region(&region_points) {
+                            shapes.push(d);
+                        }
+                        region_points.clear();
+                    }
+                    region_active = *on;
+                }
+                _ => {}
+            },
+            Command::FunctionCode(FunctionCode::DCode(d)) => match d {
+                DCode::SelectAperture(code) => current_aperture = apertures.get(code),
+                DCode::Operation(op) => match op {
+                    Operation::Move(coords) => {
+                        current_pos = coords_to_mm(coords, current_pos, units);
+                    }
+                    Operation::Interpolate(coords, _) => {
+                        let next = coords_to_mm(coords, current_pos, units);
+                        if region_active {
+                            if region_points.is_empty() {
+                                let (sx, sy) = to_svg_space(current_pos.0, current_pos.1);
+                                region_points.push((sx, sy));
+                            }
+                            let (nx, ny) = to_svg_space(next.0, next.1);
+                            region_points.push((nx, ny));
+                        }
+                        current_pos = next;
+                        let _ = interp_mode; // currently unused (linearized)
+                    }
+                    Operation::Flash(coords) => {
+                        let pos_mm = coords_to_mm(coords, current_pos, units);
+                        let (cx, cy) = to_svg_space(pos_mm.0, pos_mm.1);
+                        let ap_ref = current_aperture.or_else(|| {
+                            apertures
+                                .iter()
+                                .max_by_key(|(code, _)| *code)
+                                .map(|(_, ap)| ap)
+                        });
+                        if let Some(ap) = ap_ref {
+                            if let Some((w, h)) = aperture_bbox(ap) {
+                                shapes.push(rect_path((cx, cy), w, h));
+                            }
+                        }
+                        current_pos = pos_mm;
+                    }
+                },
+            },
+            _ => {}
+        }
+    }
+
+    // Close any pending region
+    if region_active && region_points.len() > 1 {
+        if let Some(d) = path_from_region(&region_points) {
+            shapes.push(d);
+        }
+    }
+
+    Ok(shapes)
+}

src/colorful/mod.rs

@@ -0,0 +1,112 @@
+//! Colorful silkscreen generation (FuckJLCColorfulSilkscreen port)
+//!
+//! Generates encrypted colorful silkscreen files for top/bottom layers
+//! based on board outline, user-specified images, and solder mask openings.
+
+use crate::patterns::LayerType;
+use anyhow::{Context, Result};
+use std::fs;
+use std::path::{Path, PathBuf};
+
+mod encrypt;
+pub mod mask;
+mod svg;
+mod types;
+
+pub use mask::parse_solder_mask;
+use types::{compute_mark_points, load_image, MaskPaths};
+
+const RSA_PUB_KEY: &str = r#"-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAzPtuUqJecaR/wWtctGT8
+QuVslmDH3Ut3s8c1Ls4A+M9rwpeLjgDUqfcrSrTHBrl5k/dOeJEWMeNF7STWS5jo
+WZE0H60cvf2bhormC9S6CRwq4Lw0ua0YQMo66R/qCtLVa5w6WkaPCz4b0xaHWtej
+JH49C0T67rU2DkepXuMPpwNCflMU+WgEQioZEldUTD6gYpu2U5GrW4AE0AQiIo+j
+e7tgN8PlBMbMaEfu0LokZyth1ugfuLAgyogWnedAegQmPZzAUe36Sni94AsDlhxm
+mjFl+WQZzD3MclbEY6KQB5XL8zCR/J6pCUUwfHantLxY/gQi0XJG5hWWtDyH/fR2
+lwIDAQAB
+-----END PUBLIC KEY-----"#;
+
+/// Inputs for colorful silkscreen generation
+#[derive(Debug, Clone)]
+pub struct ColorfulOptions {
+    pub top_image: Option<PathBuf>,
+    pub bottom_image: Option<PathBuf>,
+    pub top_solder_mask: Option<PathBuf>,
+    pub bottom_solder_mask: Option<PathBuf>,
+}
+
+/// Generate colorful silkscreen encrypted outputs
+pub struct ColorfulSilkscreenGenerator {
+    options: ColorfulOptions,
+}
+
+impl ColorfulSilkscreenGenerator {
+    pub fn new(options: ColorfulOptions) -> Self {
+        Self { options }
+    }
+
+    /// Generate colorful silkscreen files in the given output directory.
+    /// Returns the written file paths with their logical layer types.
+    pub fn generate(
+        &self,
+        outline_path: &Path,
+        output_dir: &Path,
+    ) -> Result<Vec<(LayerType, PathBuf)>> {
+        if self.options.top_image.is_none() && self.options.bottom_image.is_none() {
+            return Ok(Vec::new());
+        }
+
+        let outline_content = fs::read_to_string(outline_path)
+            .with_context(|| format!("Read outline {}", outline_path.display()))?;
+        let bounds = types::parse_outline_bounds(&outline_content)?;
+        let mark_points = compute_mark_points(&bounds);
+
+        fs::create_dir_all(output_dir)
+            .with_context(|| format!("Create output dir {}", output_dir.display()))?;
+
+        let key_material = encrypt::KeyMaterial::generate(RSA_PUB_KEY)?;
+        let mut written: Vec<(LayerType, PathBuf)> = Vec::new();
+
+        if let Some(top_path) = &self.options.top_image {
+            let image = load_image(top_path)?;
+            let mask = load_mask_paths(self.options.top_solder_mask.as_deref())?;
+            let svg = svg::build_top_svg(&bounds, &image, &mask);
+            let target = output_dir.join("Fabrication_ColorfulTopSilkscreen.FCTS");
+            encrypt::encrypt_and_write(&svg, &key_material, &target)?;
+            written.push((LayerType::ColorfulTopSilkscreen, target));
+        }
+
+        if let Some(bottom_path) = &self.options.bottom_image {
+            let image = load_image(bottom_path)?;
+            let mask = load_mask_paths(self.options.bottom_solder_mask.as_deref())?;
+            let svg = svg::build_bottom_svg(&bounds, &image, &mask);
+            let target = output_dir.join("Fabrication_ColorfulBottomSilkscreen.FCBS");
+            encrypt::encrypt_and_write(&svg, &key_material, &target)?;
+            written.push((LayerType::ColorfulBottomSilkscreen, target));
+        }
+
+        // Colorful board outline layer (encrypted SVG)
+        let outline_svg = svg::build_board_outline_svg(&bounds);
+        let outline_target = output_dir.join("Fabrication_ColorfulBoardOutlineLayer.FCBO");
+        encrypt::encrypt_and_write(&outline_svg, &key_material, &outline_target)?;
+        written.push((LayerType::ColorfulBoardOutline, outline_target));
+
+        // Colorful board outline mark layer (plain Gerber)
+        let mark_gerber = svg::build_outline_mark_gerber(&bounds, &mark_points);
+        let mark_target = output_dir.join("Fabrication_ColorfulBoardOutlineMark.FCBM");
+        fs::write(&mark_target, mark_gerber)
+            .with_context(|| format!("Write {}", mark_target.display()))?;
+        written.push((LayerType::ColorfulBoardOutlineMark, mark_target));
+
+        Ok(written)
+    }
+}
+
+fn load_mask_paths(path: Option<&Path>) -> Result<MaskPaths> {
+    let Some(path) = path else {
+        return Ok(Vec::new());
+    };
+    let content =
+        fs::read_to_string(path).with_context(|| format!("Read solder mask {}", path.display()))?;
+    mask::parse_solder_mask(&content)
+}