SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
STEP import: a cone bounded only by its base circle reaches its point (#258) (#3871)
bherbruck56382597378c
diff --git a/crates/kernel/src/step_in/brep.rs b/crates/kernel/src/step_in/brep.rsindex cea5a33493..bdcbf6ab49 100644--- a/crates/kernel/src/step_in/brep.rs+++ b/crates/kernel/src/step_in/brep.rs@@ -53,6 +53,63 @@ fn rid(p: Option<&Param>, what: &str) -> R<u64> {/// A contractible outer loop whose winding opposes the surface's parameter normal./// Samples follow the wire through periodic seams; a loop that winds around a surface is/// not a disk in parameter space and must retain the file's sense.+/// The point of a cone (a surface revolved from a line that meets its axis) when `ring`, a+/// face's only loop, goes once round the axis without touching it: the face then reaches the+/// point. `None` for any other surface or loop.+fn enclosed_apex(surface: &mt::Surface, ring: &mt::Wire, tol: f64) -> Option<mt::Point3> {+ use mt::Transform as _;+ let mt::Surface::RevolutedCurve(proc) = surface else { return None };+ let rc = proc.entity();+ let mt::Curve::Line(line) = rc.entity_curve() else { return None };+ let (o, axis) = (rc.origin(), rc.axis().normalize());+ // The rotation applied to the revolved surface, applied to its axis and profile too.+ let m = proc.transform();+ let (o, axis) = (m.transform_point(o), m.transform_vector(axis).normalize());+ let (p0, p1) = (m.transform_point(line.0), m.transform_point(line.1));+ let radius = |p: mt::Point3| (p - o).cross(axis).magnitude();+ let (r0, r1) = (radius(p0), radius(p1));+ if !((r0 - r1).abs() > 1e-9 * (r0 + r1)) {+ return None;+ }+ let apex = p0 + (p1 - p0) * (r0 / (r0 - r1));+ if !(radius(apex) <= tol.max(1e-9) * 10.0) {+ return None;+ }+ // Once round the axis, staying clear of it.+ let x = (p0 - o) - axis * (p0 - o).dot(axis);+ let x = if x.magnitude() > tol { x.normalize() } else { return None };+ let y = axis.cross(x);+ let mut turned = 0.0;+ let mut last: Option<f64> = None;+ let mut first: Option<f64> = None;+ for edge in ring.edge_iter() {+ let c = edge.oriented_curve();+ let (t0, t1) = c.range_tuple();+ for k in 0..16 {+ let q = c.subs(t0 + (t1 - t0) * f64::from(k) / 16.0);+ if radius(q) <= tol {+ return None;+ }+ let d = q - o;+ let ang = d.dot(y).atan2(d.dot(x));+ if let Some(l) = last {+ let mut step = ang - l;+ step -= (step / std::f64::consts::TAU).round() * std::f64::consts::TAU;+ turned += step;+ } else {+ first = Some(ang);+ }+ last = Some(ang);+ }+ }+ if let (Some(l), Some(f)) = (last, first) {+ let mut step = f - l;+ step -= (step / std::f64::consts::TAU).round() * std::f64::consts::TAU;+ turned += step;+ }+ ((turned.abs() - std::f64::consts::TAU).abs() < 0.1).then_some(apex)+}+fn reversed_outer(surface: &mt::Surface, wire: &mt::Wire, tol: f64) -> bool {if let mt::Surface::RevolutedCurve(proc) = surface {let rc = proc.entity();@@ -321,6 +378,35 @@ impl Builder {surface = guard("step surface orientation", || geom::surface(cx, sid, &extent, &seam, !sense, 0).map_err(crate::KernelError::Failed)).map_err(|e| e.to_string())?;}+ // A cone face bounded only by a ring round its axis (no vertex at the point, or a+ // VERTEX_LOOP there, which has no edges) covers the cone up to its point. Its surface+ // was spanned over the ring alone, a sliver at the base; it is spanned to the apex,+ // and the ring is joined to the apex by a seam line out and back, as a cone with a+ // seam is written.+ let (mut wires, mut surface) = (wires, surface);+ if e.name() != "FACE"+ && seam.is_empty()+ && let [ring] = wires.as_slice()+ && let Some(apex) = enclosed_apex(&surface, ring, cx.tol)+ && let Some(first) = ring.edge_iter().next()+ {+ let v = first.front().clone();+ let a = mt::Vertex::new(apex);+ let line = mt::Edge::new_unchecked(&v, &a, mt::Curve::Line(mt::Line(v.point(), apex)));+ let mut to_apex = extent.clone();+ to_apex.push(apex);+ let seam_line = [v.point(), apex];+ let sid = rid(p.get(2), "face geometry")?;+ let sense = p.get(3).and_then(Param::as_bool).unwrap_or(true);+ let spanned =+ guard("step cone to its point", || geom::surface(cx, sid, &to_apex, &seam_line, sense, 0).map_err(crate::KernelError::Failed))+ .map_err(|e| e.to_string())?;+ let mut edges: Vec<mt::Edge> = ring.edge_iter().cloned().collect();+ edges.push(line.clone());+ edges.push(line.inverse());+ wires = vec![edges.into()];+ surface = spanned;+ }// Loops on a surface of revolution start away from the axis: a pole (cone apex, sphere// pole) has no definite rotation parameter, and the mesher takes the first point's// parameter as the anchor for the rest of the loop.diff --git a/crates/kernel/src/step_in/conic_tests.rs b/crates/kernel/src/step_in/conic_tests.rsindex 05d4ddf47b..5ed01d8cc8 100644--- a/crates/kernel/src/step_in/conic_tests.rs+++ b/crates/kernel/src/step_in/conic_tests.rs@@ -236,3 +236,40 @@ fn hostile_conics_never_panic() {}}}++/// A cone to a point written with no vertex at its point (#258): the cone face's only loop is+/// its base circle, or that circle and a VERTEX_LOOP at the point, which has no edges. It was+/// read as a sliver at the base and the solid came in as a flat disc; the face reaches the+/// point now.+#[test]+fn a_cone_bounded_only_by_its_base_circle_reaches_its_point() {+ let (r, h) = (6.0f64, 15.0f64);+ for apex_loop in [false, true] {+ let mut t = String::from(HEAD);+ t += "#1=CARTESIAN_POINT('',(0.,0.,0.));\n#2=DIRECTION('',(0.,0.,-1.));\n#3=DIRECTION('',(1.,0.,0.));\n#4=AXIS2_PLACEMENT_3D('',#1,#2,#3);\n";+ t += &format!("#5=CONICAL_SURFACE('',#4,{r:.1},{:.15});\n", (r / h).atan());+ t += "#6=DIRECTION('',(0.,0.,1.));\n#7=AXIS2_PLACEMENT_3D('',#1,#6,#3);\n#8=PLANE('',#7);\n";+ t += &format!("#9=CIRCLE('',#7,{r:.1});\n#10=CARTESIAN_POINT('',({r:.1},0.,0.));\n#11=VERTEX_POINT('',#10);\n");+ t += "#12=EDGE_CURVE('',#11,#11,#9,.T.);\n";+ t += "#20=ORIENTED_EDGE('',*,*,#12,.F.);\n#21=EDGE_LOOP('',(#20));\n#22=FACE_OUTER_BOUND('',#21,.T.);\n#23=ADVANCED_FACE('',(#22),#8,.F.);\n";+ t += "#30=ORIENTED_EDGE('',*,*,#12,.T.);\n#31=EDGE_LOOP('',(#30));\n#32=FACE_OUTER_BOUND('',#31,.T.);\n";+ if apex_loop {+ t += &format!(+ "#33=CARTESIAN_POINT('',(0.,0.,{h:.1}));\n#34=VERTEX_POINT('',#33);\n#35=VERTEX_LOOP('',#34);\n#36=FACE_BOUND('',#35,.T.);\n"+ );+ t += "#37=ADVANCED_FACE('',(#32,#36),#5,.T.);\n";+ } else {+ t += "#37=ADVANCED_FACE('',(#32),#5,.T.);\n";+ }+ t += "#80=CLOSED_SHELL('',(#23,#37));\n#81=MANIFOLD_SOLID_BREP('Cone',#80);\n";+ t += CONTEXT;+ t += TAIL;+ let imp = step_import(&t).unwrap();+ let body = &imp.bodies[0].body;+ let m = measure(body).unwrap();+ let exact = PI * r * r * h / 3.0;+ assert!(rel(m.volume, exact) < 2e-3, "vertex loop {apex_loop}: volume {} vs {exact}", m.volume);+ let top = body.tessellate(0.01).unwrap().positions.iter().map(|p| p.z).fold(f64::MIN, f64::max);+ assert!((top - h).abs() < 1e-6, "vertex loop {apex_loop}: reaches z = {top}, not {h}");+ }+}