Adom Library

@@ -37,6 +37,15 @@ enum Commands {         /// Symbol name override         #[arg(long)]         name: Option<String>,+        /// Path to an adom-symbol outline SVG (a vector line-drawing of the+        /// chip). When given, it's drawn as raw `<wire>` lines on the schematic+        /// symbol, centred in the symbol body.+        #[arg(long)]+        symbol_art: Option<PathBuf>,+        /// Size of the symbol art as a fraction of the symbol body's smaller+        /// side (default 0.38, matching adom-symbol's placement). Higher = bigger.+        #[arg(long, default_value_t = 0.38)]+        symbol_art_scale: f64,         /// Path to a 3D model (STEP/STP/GLB) to associate with the package.         /// The .lbr stays 2D-only (a valid Fusion 3D ref needs an Autodesk         /// cloud URN that can only be minted by Fusion). Instead, a sidecar@@ -882,7 +891,88 @@ fn bind_3d_urn(content: &str, link: &str, managed: bool, package: Option<&str>)     Ok(out) } -fn generate_lbr(sym: &ParsedSymbol, fp_content: Option<&str>) -> String {+/// Transcribe an adom-symbol outline SVG (a flattened line drawing of the chip)+/// into EAGLE symbol `<wire>`s on layer 94, so the schematic symbol carries a+/// little vector picture of the part. The SVG uses `<polyline>`/`<polygon>`+/// `points=` in a Y-down pixel space; we decimate the dense sampling, fit the+/// drawing inside the symbol body (centred), and negate Y for EAGLE's Y-up.+/// Returns the `<wire>` block plus the segment count (for a hint).+fn symbol_art_wires(svg: &str, body: Option<&KicadBody>, scale_frac: f64) -> (String, usize) {+    let poly_re = regex_lite::Regex::new(r#"<(polyline|polygon)\b[^>]*\bpoints="([^"]+)""#).unwrap();+    let mut polys: Vec<Vec<(f64, f64)>> = Vec::new();+    for c in poly_re.captures_iter(svg) {+        let closed = &c[1] == "polygon";+        let mut pts: Vec<(f64, f64)> = c[2]+            .split_whitespace()+            .filter_map(|p| {+                let mut it = p.split(',');+                let x: f64 = it.next()?.trim().parse().ok()?;+                let y: f64 = it.next()?.trim().parse().ok()?;+                Some((x, y))+            })+            .collect();+        if closed {+            if let Some(&first) = pts.first() { pts.push(first); }+        }+        polys.push(pts);+    }+    // Global bbox of every point (in SVG units).+    let (mut minx, mut miny, mut maxx, mut maxy) = (f64::MAX, f64::MAX, f64::MIN, f64::MIN);+    for poly in &polys {+        for &(x, y) in poly {+            minx = minx.min(x); miny = miny.min(y);+            maxx = maxx.max(x); maxy = maxy.max(y);+        }+    }+    let (sw, sh) = (maxx - minx, maxy - miny);+    if !(sw > 0.0 && sh > 0.0) {+        return (String::new(), 0);+    }+    // Fit a modest, centred icon — matching adom-symbol's own placement, which+    // sizes the outline to ~half the body's smaller side so it sits between the+    // pins/labels without crowding them.+    let (target, cx, cy) = match body {+        Some(b) => {+            let bw = (b.right - b.left).abs();+            let bh = (b.top - b.bottom).abs();+            (bw.min(bh) * scale_frac, (b.left + b.right) / 2.0, (b.top + b.bottom) / 2.0)+        }+        None => (26.0 * scale_frac, 0.0, 0.0),+    };+    let scale = target / sw.max(sh);+    // Decimate in OUTPUT space: drop points within `tol_mm` of the last kept one,+    // so curves stay smooth but the dense sampling collapses.+    let tol_mm = 0.12;+    let (smx, smy) = ((minx + maxx) / 2.0, (miny + maxy) / 2.0);+    let map = |x: f64, y: f64| (cx + (x - smx) * scale, cy - (y - smy) * scale);++    let mut out = String::new();+    let mut segs = 0usize;+    for poly in &polys {+        let mut kept: Vec<(f64, f64)> = Vec::new();+        let n = poly.len();+        for (i, &(px, py)) in poly.iter().enumerate() {+            let p = map(px, py);+            if i == 0 || i == n - 1 {+                kept.push(p);+            } else if let Some(&last) = kept.last() {+                if ((p.0 - last.0).powi(2) + (p.1 - last.1).powi(2)).sqrt() >= tol_mm {+                    kept.push(p);+                }+            }+        }+        for w in kept.windows(2) {+            out.push_str(&format!(+                "  <wire x1=\"{:.4}\" y1=\"{:.4}\" x2=\"{:.4}\" y2=\"{:.4}\" width=\"0.1016\" layer=\"94\"/>\n",+                w[0].0, w[0].1, w[1].0, w[1].1+            ));+            segs += 1;+        }+    }+    (out, segs)+}++fn generate_lbr(sym: &ParsedSymbol, fp_content: Option<&str>, symbol_art: Option<&str>, symbol_art_scale: f64) -> String {     let mut xml = String::with_capacity(8192);      xml.push_str("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");@@ -999,6 +1089,13 @@ fn generate_lbr(sym: &ParsedSymbol, fp_content: Option<&str>) -> String {         xml.push_str(&format!("  <wire x1=\"{}\" y1=\"{}\" x2=\"{}\" y2=\"{}\" width=\"0.254\" layer=\"94\"/>\n", body.left, body.bottom, body.left, body.top));     } +    // Optional: a vector drawing of the chip (adom-symbol's outline SVG) drawn+    // as raw lines, centred inside the symbol body.+    if let Some(svg) = symbol_art {+        let (art, _) = symbol_art_wires(svg, sym.body.as_ref(), symbol_art_scale);+        xml.push_str(&art);+    }+     let name_y = sym.body.as_ref().map(|b| b.top + 2.54).unwrap_or(10.0);     let value_y = sym.body.as_ref().map(|b| b.bottom - 2.54).unwrap_or(-10.0);     xml.push_str(&format!("  <text x=\"0\" y=\"{}\" size=\"1.27\" layer=\"95\" align=\"bottom-center\">&gt;NAME</text>\n", name_y));@@ -1209,7 +1306,13 @@ fn main() {     let cli = Cli::parse();      match cli.command {-        Commands::Generate { sym, fp, output, name, model } => {+        Commands::Generate { sym, fp, output, name, model, symbol_art, symbol_art_scale } => {+            let symbol_art_content = symbol_art.as_ref().map(|p| {+                fs::read_to_string(p).unwrap_or_else(|e| {+                    eprintln!("ERROR: Cannot read symbol art {}: {}", p.display(), e);+                    process::exit(1);+                })+            });             let fp_content = fp.as_ref().map(|p| {                 fs::read_to_string(p).unwrap_or_else(|e| {                     eprintln!("ERROR: Cannot read footprint {}: {}", p.display(), e);@@ -1244,7 +1347,7 @@ fn main() {             };              let out_default = sym.as_ref().or(fp.as_ref()).cloned().unwrap_or_else(|| PathBuf::from(&parsed.name));-            let lbr = generate_lbr(&parsed, fp_content.as_deref());+            let lbr = generate_lbr(&parsed, fp_content.as_deref(), symbol_art_content.as_deref(), symbol_art_scale);              // Lint before writing             let lint = lint_lbr(&lbr);@@ -1283,6 +1386,23 @@ fn main() {                     println!("HINT: add --model <part.step> to also emit a Fusion 3D handoff sidecar (the bridge attaches the body).");                 }             }+            if let Some(svg) = &symbol_art_content {+                let (_, segs) = symbol_art_wires(svg, parsed.body.as_ref(), symbol_art_scale);+                let kb = lbr.len() / 1024;+                if segs == 0 {+                    println!("HINT: --symbol-art SVG had NO <polyline>/<polygon> points — nothing drawn. Give a flattened outline SVG (adom-symbol's `<mpn>-3d-outline-*.svg`), not a raster or a <path>-only file.");+                } else {+                    println!("HINT: drew the chip outline on the symbol — {segs} segments on layer 94, centred + scaled to the symbol body (matching adom-symbol's placement).");+                    if segs > 2500 || kb > 200 {+                        println!("WARN: HEAVY symbol art — {segs} segments, ~{kb} KB .lbr. Detailed outlines (e.g. `-blueprint`) bloat the library and can lag Fusion's symbol editor.");+                        println!("      → Pass a SIMPLER outline instead (`<mpn>-3d-outline-bold.svg` or `-thin.svg` are ~1/3 the size), or drop the art for a 19 KB symbol.");+                    } else if kb > 80 {+                        println!("HINT: moderate weight (~{kb} KB). Fine for one part; if you're batching a whole library, prefer the lighter `-bold`/`-thin` outlines.");+                    } else {+                        println!("HINT: light + clean (~{kb} KB). Want the full iso wireframe? a `-blueprint` outline has more detail (bigger file).");+                    }+                }+            }             println!("NEXT: this .lbr imports directly into Fusion 360 / Altium / OrCAD. For KiCad: `adom-lbr import {} -o part.kicad_sym`.", out_path.display());              // 3D model: emit a sidecar manifest for the Fusion bridge. A valid