Skip to content

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.rs
index 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.rs
index 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}");
+ }
+}