feat(sheet-metal): foundation tier — vcad-kernel-sheet + design spec

Cargo.toml

@@ -16,6 +16,7 @@ members = [
     "crates/vcad-kernel-text",
     "crates/vcad-kernel-sweep",
     "crates/vcad-kernel-shell",
+    "crates/vcad-kernel-sheet",
     "crates/vcad-kernel-step",
     "crates/vcad-kernel",
     "crates/vcad-kernel-constraints",
@@ -76,6 +77,7 @@ default-members = [
     "crates/vcad-kernel-text",
     "crates/vcad-kernel-sweep",
     "crates/vcad-kernel-shell",
+    "crates/vcad-kernel-sheet",
     "crates/vcad-kernel-step",
     "crates/vcad-kernel",
     "crates/vcad-kernel-constraints",
@@ -154,6 +156,7 @@ vcad-kernel-fillet = { path = "crates/vcad-kernel-fillet", version = "0.9.4" }
 vcad-kernel-sketch = { path = "crates/vcad-kernel-sketch", version = "0.9.4" }
 vcad-kernel-sweep = { path = "crates/vcad-kernel-sweep", version = "0.9.4" }
 vcad-kernel-shell = { path = "crates/vcad-kernel-shell", version = "0.9.4" }
+vcad-kernel-sheet = { path = "crates/vcad-kernel-sheet", version = "0.9.4" }
 vcad-kernel-step = { path = "crates/vcad-kernel-step", version = "0.9.4" }
 vcad-kernel-constraints = { path = "crates/vcad-kernel-constraints", version = "0.9.4" }
 vcad-kernel-drafting = { path = "crates/vcad-kernel-drafting", version = "0.9.4" }

crates/vcad-kernel-sheet/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "vcad-kernel-sheet"
+description = "Sheet-metal modeling for the vcad kernel: flanges, bends, lossless unfold"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+
+[dependencies]
+vcad-kernel-math = { workspace = true }
+
+[dev-dependencies]

crates/vcad-kernel-sheet/src/base_flange.rs

@@ -0,0 +1,144 @@
+//! [`SheetMetalModel`] constructors — the "base flange" operations.
+//!
+//! Foundation tier supports a rectangular base flange and a generic
+//! polygon outline. Sketch-driven flanges (via `vcad-kernel-sketch`) come
+//! later; we don't drag the sketch crate into the foundation.
+
+use crate::model::{Frame, Panel, SheetMetalModel};
+use vcad_kernel_math::Point2;
+
+/// Errors returned by base-flange construction.
+#[derive(Debug, Clone, PartialEq)]
+pub enum BaseFlangeError {
+    /// Thickness must be > 0.
+    InvalidThickness(f64),
+    /// Outline must have at least 3 distinct points.
+    OutlineTooSmall(usize),
+    /// Width / depth must be > 0.
+    NonPositiveDimension(&'static str, f64),
+}
+
+impl std::fmt::Display for BaseFlangeError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            BaseFlangeError::InvalidThickness(t) => write!(f, "thickness must be > 0, got {t}"),
+            BaseFlangeError::OutlineTooSmall(n) => {
+                write!(f, "outline needs >= 3 points, got {n}")
+            }
+            BaseFlangeError::NonPositiveDimension(name, v) => {
+                write!(f, "{name} must be > 0, got {v}")
+            }
+        }
+    }
+}
+
+impl std::error::Error for BaseFlangeError {}
+
+/// Build a sheet-metal model from a closed polygon outline.
+///
+/// The outline lies in the XY plane; the panel's outside face is on +Z and
+/// inside face on -Z, with the panel's inside surface at z=0.
+pub fn base_flange_polygon(
+    outline: Vec<Point2>,
+    thickness: f64,
+) -> Result<SheetMetalModel, BaseFlangeError> {
+    if thickness <= 0.0 || thickness.is_nan() {
+        return Err(BaseFlangeError::InvalidThickness(thickness));
+    }
+    if outline.len() < 3 {
+        return Err(BaseFlangeError::OutlineTooSmall(outline.len()));
+    }
+    let mut model = SheetMetalModel::new(thickness);
+    let panel = Panel {
+        outline,
+        holes: Vec::new(),
+        frame_bent: Frame::identity(),
+        frame_flat: Frame::identity(),
+        incident_bends: Vec::new(),
+    };
+    model.root = model.push_panel(panel);
+    Ok(model)
+}
+
+/// Build a sheet-metal model from an axis-aligned rectangle in the XY plane.
+///
+/// Corner at origin, extending into +X and +Y by `(width, depth)`. The panel's
+/// outside face points along +Z.
+pub fn base_flange_rect(
+    width: f64,
+    depth: f64,
+    thickness: f64,
+) -> Result<SheetMetalModel, BaseFlangeError> {
+    if width <= 0.0 || width.is_nan() {
+        return Err(BaseFlangeError::NonPositiveDimension("width", width));
+    }
+    if depth <= 0.0 || depth.is_nan() {
+        return Err(BaseFlangeError::NonPositiveDimension("depth", depth));
+    }
+    base_flange_polygon(
+        vec![
+            Point2::new(0.0, 0.0),
+            Point2::new(width, 0.0),
+            Point2::new(width, depth),
+            Point2::new(0.0, depth),
+        ],
+        thickness,
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn rect_creates_single_panel() {
+        let m = base_flange_rect(100.0, 50.0, 1.0).unwrap();
+        assert_eq!(m.panels.len(), 1);
+        assert_eq!(m.bends.len(), 0);
+        assert_eq!(m.root, 0);
+        assert_eq!(m.thickness, 1.0);
+        assert_eq!(m.panels[0].outline.len(), 4);
+    }
+
+    #[test]
+    fn rect_rejects_zero_thickness() {
+        assert!(matches!(
+            base_flange_rect(100.0, 50.0, 0.0),
+            Err(BaseFlangeError::InvalidThickness(_))
+        ));
+    }
+
+    #[test]
+    fn rect_rejects_negative_dim() {
+        assert!(matches!(
+            base_flange_rect(-1.0, 50.0, 1.0),
+            Err(BaseFlangeError::NonPositiveDimension("width", _))
+        ));
+        assert!(matches!(
+            base_flange_rect(100.0, -1.0, 1.0),
+            Err(BaseFlangeError::NonPositiveDimension("depth", _))
+        ));
+    }
+
+    #[test]
+    fn polygon_rejects_degenerate_outline() {
+        assert!(matches!(
+            base_flange_polygon(vec![Point2::new(0.0, 0.0), Point2::new(1.0, 0.0)], 1.0),
+            Err(BaseFlangeError::OutlineTooSmall(2))
+        ));
+    }
+
+    #[test]
+    fn rect_outline_is_ccw() {
+        // Signed area of a CCW polygon is positive.
+        let m = base_flange_rect(10.0, 5.0, 1.0).unwrap();
+        let outline = &m.panels[0].outline;
+        let area: f64 = outline
+            .windows(2)
+            .map(|w| w[0].x * w[1].y - w[1].x * w[0].y)
+            .sum::<f64>()
+            + (outline.last().unwrap().x * outline.first().unwrap().y
+                - outline.first().unwrap().x * outline.last().unwrap().y);
+        assert!(area > 0.0, "outline not CCW: signed area {area}");
+    }
+}