Adom Footprint

@@ -25,16 +25,54 @@ pub struct Pad { struct Seg { x1: f64, y1: f64, x2: f64, y2: f64 } struct Rect { x1: f64, y1: f64, x2: f64, y2: f64 } struct Poly { pts: Vec<(f64, f64)> }+struct Circle { cx: f64, cy: f64, r: f64, filled: bool }  pub struct Footprint {     pub pads: Vec<Pad>,     courtyard_lines: Vec<Seg>,     courtyard_rects: Vec<Rect>,+    courtyard_arcs: Vec<Poly>,+    courtyard_circles: Vec<Circle>,     fab_lines: Vec<Seg>,     fab_rects: Vec<Rect>,     fab_polys: Vec<Poly>,+    fab_arcs: Vec<Poly>,+    fab_circles: Vec<Circle>,     silk_lines: Vec<Seg>,     silk_polys: Vec<Poly>,+    silk_arcs: Vec<Poly>,+    silk_circles: Vec<Circle>,+}++/// Sample a KiCad *legacy* arc — `(start=CENTER) (end=ARC-START-POINT) (angle …)` —+/// into a polyline. Robust regardless of stroke flags; 1 segment per ~10°.+fn arc_from_legacy(cx: f64, cy: f64, sx: f64, sy: f64, angle_deg: f64) -> Vec<(f64, f64)> {+    let r = ((sx - cx).powi(2) + (sy - cy).powi(2)).sqrt();+    let a0 = (sy - cy).atan2(sx - cx);+    let sweep = angle_deg.to_radians();+    let n = ((angle_deg.abs() / 10.0).ceil() as usize).clamp(2, 64);+    (0..=n).map(|i| { let a = a0 + sweep * (i as f64 / n as f64); (cx + r * a.cos(), cy + r * a.sin()) }).collect()+}++/// Sample a KiCad *modern* three-point arc — `(start) (mid) (end)` — into a+/// polyline. Finds the circumcircle, then sweeps start→end through mid.+fn arc_from_3pt(sx: f64, sy: f64, mx: f64, my: f64, ex: f64, ey: f64) -> Vec<(f64, f64)> {+    use std::f64::consts::PI;+    let d = 2.0 * (sx * (my - ey) + mx * (ey - sy) + ex * (sy - my));+    if d.abs() < 1e-9 { return vec![(sx, sy), (ex, ey)]; } // collinear → straight+    let (s2, m2, e2) = (sx * sx + sy * sy, mx * mx + my * my, ex * ex + ey * ey);+    let cx = (s2 * (my - ey) + m2 * (ey - sy) + e2 * (sy - my)) / d;+    let cy = (s2 * (ex - mx) + m2 * (sx - ex) + e2 * (mx - sx)) / d;+    let r = ((sx - cx).powi(2) + (sy - cy).powi(2)).sqrt();+    let a0 = (sy - cy).atan2(sx - cx);+    let am = (my - cy).atan2(mx - cx);+    let a1 = (ey - cy).atan2(ex - cx);+    let n2pi = |a: f64| { let mut a = a % (2.0 * PI); if a < 0.0 { a += 2.0 * PI; } a };+    let sweep_ccw = n2pi(a1 - a0);+    let mid_ccw = n2pi(am - a0);+    let sweep = if mid_ccw <= sweep_ccw { sweep_ccw } else { sweep_ccw - 2.0 * PI };+    let n = ((sweep.abs().to_degrees() / 10.0).ceil() as usize).clamp(2, 64);+    (0..=n).map(|i| { let a = a0 + sweep * (i as f64 / n as f64); (cx + r * a.cos(), cy + r * a.sin()) }).collect() }  /// Balanced-paren slice of every `(<tag> …)` block.@@ -69,16 +107,27 @@ pub fn parse(content: &str) -> Footprint {     let size_re = Regex::new(r"\(size\s+(-?[\d.]+)\s+(-?[\d.]+)\)").unwrap();     let drill_re = Regex::new(r"\(drill\s+(-?[\d.]+)").unwrap();     let rr_re = Regex::new(r"\(roundrect_rratio\s+([\d.]+)\)").unwrap();-    let layer_re = Regex::new(r##"\(layer\s+"([^"]+)"\)"##).unwrap();+    // Accept BOTH quoted `(layer "F.SilkS")` and bare `(layer F.SilkS)` — vendor /+    // manufacturer footprints (and older KiCad) write the layer name unquoted, and+    // requiring quotes silently dropped all their silk/courtyard/fab geometry.+    let layer_re = Regex::new(r##"\(layer\s+"?([^"()\s]+)"?\s*\)"##).unwrap();     let se_re = Regex::new(r"\(start\s+(-?[\d.]+)\s+(-?[\d.]+)\)\s*\(end\s+(-?[\d.]+)\s+(-?[\d.]+)\)").unwrap();     // Pad number may be quoted ("13") or bare (13, older KiCad) — accept both.     let pad_head = Regex::new(r##"\(pad\s+"?([^"\s]+)"?\s+(\w+)\s+(\w+)"##).unwrap();     let xy_re = Regex::new(r"\(xy\s+(-?[\d.]+)\s+(-?[\d.]+)\)").unwrap();+    let start_re = Regex::new(r"\(start\s+(-?[\d.]+)\s+(-?[\d.]+)\)").unwrap();+    let end_re = Regex::new(r"\(end\s+(-?[\d.]+)\s+(-?[\d.]+)\)").unwrap();+    let mid_re = Regex::new(r"\(mid\s+(-?[\d.]+)\s+(-?[\d.]+)\)").unwrap();+    let angle_re = Regex::new(r"\(angle\s+(-?[\d.]+)\)").unwrap();+    let center_re = Regex::new(r"\(center\s+(-?[\d.]+)\s+(-?[\d.]+)\)").unwrap();      let mut fp = Footprint {         pads: vec![], courtyard_lines: vec![], courtyard_rects: vec![],+        courtyard_arcs: vec![], courtyard_circles: vec![],         fab_lines: vec![], fab_rects: vec![], fab_polys: vec![],+        fab_arcs: vec![], fab_circles: vec![],         silk_lines: vec![], silk_polys: vec![],+        silk_arcs: vec![], silk_circles: vec![],     };      // ── Pads ──@@ -131,6 +180,39 @@ pub fn parse(content: &str) -> Footprint {             _ => {}         }     }+    // ── fp_arc by layer (sampled to a polyline) ──+    for b in blocks(content, "fp_arc") {+        let (s, e) = match (start_re.captures(b), end_re.captures(b)) { (Some(s), Some(e)) => (s, e), _ => continue };+        let (sx, sy) = (s[1].parse().unwrap_or(0.0), s[2].parse().unwrap_or(0.0));+        let (ex, ey) = (e[1].parse().unwrap_or(0.0), e[2].parse().unwrap_or(0.0));+        let pts = if let Some(m) = mid_re.captures(b) {+            arc_from_3pt(sx, sy, m[1].parse().unwrap_or(0.0), m[2].parse().unwrap_or(0.0), ex, ey)+        } else if let Some(a) = angle_re.captures(b) {+            // legacy: start = centre, end = a point on the arc+            arc_from_legacy(sx, sy, ex, ey, a[1].parse().unwrap_or(0.0))+        } else { vec![(sx, sy), (ex, ey)] };+        match layer_of(b, &layer_re).as_str() {+            "F.CrtYd" => fp.courtyard_arcs.push(Poly { pts }),+            "F.Fab" => fp.fab_arcs.push(Poly { pts }),+            "F.SilkS" => fp.silk_arcs.push(Poly { pts }),+            _ => {}+        }+    }+    // ── fp_circle by layer (center + a point on the circle) ──+    for b in blocks(content, "fp_circle") {+        let (c, e) = match (center_re.captures(b), end_re.captures(b)) { (Some(c), Some(e)) => (c, e), _ => continue };+        let (cx, cy): (f64, f64) = (c[1].parse().unwrap_or(0.0), c[2].parse().unwrap_or(0.0));+        let (ex, ey): (f64, f64) = (e[1].parse().unwrap_or(0.0), e[2].parse().unwrap_or(0.0));+        let r = ((ex - cx).powi(2) + (ey - cy).powi(2)).sqrt();+        let filled = b.contains("(fill solid)") || b.contains("(fill yes)");+        let circ = Circle { cx, cy, r, filled };+        match layer_of(b, &layer_re).as_str() {+            "F.CrtYd" => fp.courtyard_circles.push(circ),+            "F.Fab" => fp.fab_circles.push(circ),+            "F.SilkS" => fp.silk_circles.push(circ),+            _ => {}+        }+    }     fp } @@ -145,7 +227,13 @@ pub fn render(fp: &Footprint) -> (String, f64, f64) {     for p in &fp.pads { pts.push((p.x - p.w / 2.0, p.y - p.h / 2.0)); pts.push((p.x + p.w / 2.0, p.y + p.h / 2.0)); }     for s in fp.courtyard_lines.iter().chain(fp.fab_lines.iter()).chain(fp.silk_lines.iter()) { pts.push((s.x1, s.y1)); pts.push((s.x2, s.y2)); }     for r in fp.courtyard_rects.iter().chain(fp.fab_rects.iter()) { pts.push((r.x1, r.y1)); pts.push((r.x2, r.y2)); }-    for poly in fp.fab_polys.iter().chain(fp.silk_polys.iter()) { for &pt in &poly.pts { pts.push(pt); } }+    for poly in fp.fab_polys.iter().chain(fp.silk_polys.iter())+        .chain(fp.courtyard_arcs.iter()).chain(fp.fab_arcs.iter()).chain(fp.silk_arcs.iter()) {+        for &pt in &poly.pts { pts.push(pt); }+    }+    for c in fp.courtyard_circles.iter().chain(fp.fab_circles.iter()).chain(fp.silk_circles.iter()) {+        pts.push((c.cx - c.r, c.cy - c.r)); pts.push((c.cx + c.r, c.cy + c.r));+    }     if pts.is_empty() { pts.push((-5.0, -5.0)); pts.push((5.0, 5.0)); }     let margin = 1.0;     let min_x = pts.iter().map(|p| p.0).fold(f64::INFINITY, f64::min) - margin;@@ -161,6 +249,8 @@ pub fn render(fp: &Footprint) -> (String, f64, f64) {     s.push_str(r##"<g class="adom-layer-courtyard">"##);     for l in &fp.courtyard_lines { let _ = write!(s, r##"<line x1="{:.3}" y1="{:.3}" x2="{:.3}" y2="{:.3}" stroke="#FF26E2" stroke-width="0.05" stroke-dasharray="0.2,0.1"/>"##, l.x1, l.y1, l.x2, l.y2); }     for r in &fp.courtyard_rects { let _ = write!(s, r##"<rect x="{:.3}" y="{:.3}" width="{:.3}" height="{:.3}" fill="none" stroke="#FF26E2" stroke-width="0.05" stroke-dasharray="0.2,0.1"/>"##, r.x1.min(r.x2), r.y1.min(r.y2), (r.x2 - r.x1).abs(), (r.y2 - r.y1).abs()); }+    for a in &fp.courtyard_arcs { let _ = write!(s, r##"<path d="{}" fill="none" stroke="#FF26E2" stroke-width="0.05" stroke-dasharray="0.2,0.1"/>"##, polyline_d(&a.pts)); }+    for c in &fp.courtyard_circles { let _ = write!(s, r##"<circle cx="{:.3}" cy="{:.3}" r="{:.3}" fill="none" stroke="#FF26E2" stroke-width="0.05" stroke-dasharray="0.2,0.1"/>"##, c.cx, c.cy, c.r); }     s.push_str("</g>");      // ── Fab outline (grey) ──@@ -168,6 +258,8 @@ pub fn render(fp: &Footprint) -> (String, f64, f64) {     for l in &fp.fab_lines { let _ = write!(s, r##"<line x1="{:.3}" y1="{:.3}" x2="{:.3}" y2="{:.3}" stroke="#6e7681" stroke-width="0.1"/>"##, l.x1, l.y1, l.x2, l.y2); }     for r in &fp.fab_rects { let _ = write!(s, r##"<rect x="{:.3}" y="{:.3}" width="{:.3}" height="{:.3}" fill="none" stroke="#6e7681" stroke-width="0.1"/>"##, r.x1.min(r.x2), r.y1.min(r.y2), (r.x2 - r.x1).abs(), (r.y2 - r.y1).abs()); }     for poly in &fp.fab_polys { let d = poly_d(&poly.pts); let _ = write!(s, r##"<path d="{}" fill="none" stroke="#6e7681" stroke-width="0.1"/>"##, d); }+    for a in &fp.fab_arcs { let _ = write!(s, r##"<path d="{}" fill="none" stroke="#6e7681" stroke-width="0.1"/>"##, polyline_d(&a.pts)); }+    for c in &fp.fab_circles { let _ = write!(s, r##"<circle cx="{:.3}" cy="{:.3}" r="{:.3}" fill="{}" stroke="#6e7681" stroke-width="0.1"/>"##, c.cx, c.cy, c.r, if c.filled { "#6e7681" } else { "none" }); }     s.push_str("</g>");      // ── Copper pads (red) ──@@ -202,6 +294,8 @@ pub fn render(fp: &Footprint) -> (String, f64, f64) {     s.push_str(r##"<g class="adom-layer-silk">"##);     for l in &fp.silk_lines { let _ = write!(s, r##"<line x1="{:.3}" y1="{:.3}" x2="{:.3}" y2="{:.3}" stroke="#00cccc" stroke-width="0.12" stroke-linecap="round"/>"##, l.x1, l.y1, l.x2, l.y2); }     for poly in &fp.silk_polys { let d = poly_d(&poly.pts); let _ = write!(s, r##"<path d="{}" fill="#00cccc" stroke="#00cccc" stroke-width="0.1"/>"##, d); }+    for a in &fp.silk_arcs { let _ = write!(s, r##"<path d="{}" fill="none" stroke="#00cccc" stroke-width="0.12" stroke-linecap="round"/>"##, polyline_d(&a.pts)); }+    for c in &fp.silk_circles { let _ = write!(s, r##"<circle cx="{:.3}" cy="{:.3}" r="{:.3}" fill="{}" stroke="#00cccc" stroke-width="0.12"/>"##, c.cx, c.cy, c.r, if c.filled { "#00cccc" } else { "none" }); }     s.push_str("</g>");      // ── Pad numbers (white) ──@@ -227,3 +321,12 @@ fn poly_d(pts: &[(f64, f64)]) -> String {     d.push('Z');     d }++/// Like `poly_d` but leaves the path OPEN (no `Z`) — for arcs/polylines.+fn polyline_d(pts: &[(f64, f64)]) -> String {+    let mut d = String::new();+    for (i, &(x, y)) in pts.iter().enumerate() {+        let _ = write!(d, "{}{:.3},{:.3} ", if i == 0 { "M" } else { "L" }, x, y);+    }+    d+}