From 76a254137c52502f9fec5827496a3ca064b938cd Mon Sep 17 00:00:00 2001 From: jyviko <2501648+jyviko@users.noreply.github.com> Date: Fri, 23 Oct 2026 17:04:39 -0400 Subject: [PATCH] sew: a circle on a revolved face is labelled on that face's frame MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The bend's rim arcs carried frames of their own (x toward the arc's start), a fraction of a quarter from the bend cylinder's, so their forms were off the cylinder's quarter grid and no straight pcurve lay along them. `form::on_frame` relabels such a circle on the face's frame (the same circle, its interval shifted); its form is then on the face's grid, its pcurve u = ±s + c. `along` takes u or v as the edge's parameter either way along, offset. The volume test steps to a pcurve's ends exactly (t0(1-f) + t1 f), as an interval's end may now carry rounding. With the fit off, 38 of the 44 sew cases pass (from 29). With it on, the rig is unchanged (333/372, ladder 101/116, no case changed). Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01BnQawySUFx57iaJZq7z1Fm --- crates/geom/src/brep/form.rs | 19 +++++++++++++++++ crates/geom/src/brep/pcurve.rs | 10 +++++++-- crates/kernel/src/sew.rs | 39 +++++++++++++++++++++++++++------- 3 files changed, 58 insertions(+), 10 deletions(-) diff --git a/crates/geom/src/brep/form.rs b/crates/geom/src/brep/form.rs index f25809952..2995e6267 100644 --- a/crates/geom/src/brep/form.rs +++ b/crates/geom/src/brep/form.rs @@ -176,3 +176,22 @@ pub fn surface(s: &Surface, [u, v]: [[f64; 2]; 2]) -> Option<(Surface, [[f64; 2] _ => None, } } + +/// A circle edge labelled on another frame about the same axis: the same circle, its angle +/// measured from `frame`'s x axis (its y axis taken so the circle keeps its own direction), and +/// its interval shifted to match, so its form lies on `frame`'s quarter grid. `None` when the +/// circle is not about `frame`'s axis (centre on it, normal along it, within `tol`). +pub fn on_frame(c: &Curve, [t0, t1]: [f64; 2], frame: &Frame, tol: f64) -> Option<(Curve, [f64; 2])> { + let Curve::Circle { frame: own, radius } = c else { return None }; + let (o, x, _, z) = axes(own)?; + let (fo, fx, _, fz) = axes(frame)?; + let d = o - fo; + if !((d - fz * d.dot(fz)).len() <= tol && (z.dot(fz).abs() - 1.0).abs() <= 1e-9) { + return None; + } + let nx = (fx - z * fx.dot(z)).normalized()?; + let ny = z.cross(nx); + let shift = x.dot(ny).atan2(x.dot(nx)); + let relabel = Frame { origin: [o.x, o.y, o.z], x_axis: [nx.x, nx.y, nx.z], y_axis: [ny.x, ny.y, ny.z] }; + Some((Curve::Circle { frame: relabel, radius: *radius }, [t0 + shift, t1 + shift])) +} diff --git a/crates/geom/src/brep/pcurve.rs b/crates/geom/src/brep/pcurve.rs index 4ecd8b844..1bcfd88db 100644 --- a/crates/geom/src/brep/pcurve.rs +++ b/crates/geom/src/brep/pcurve.rs @@ -317,9 +317,15 @@ impl On { if let (Some(a), Some(b)) = (self.project(p0, None, exact), self.project(p1, None, exact)) { candidates.push(line(a, b)); } + // u or v the edge's own parameter, either way along and offset (forms on one frame's + // quarter grid, or on the same grid turned over), the other fixed. if let Some([u, v]) = self.project(pm, None, exact) { - candidates.push(line([t0, v], [t1, v])); - candidates.push(line([u, t0], [u, t1])); + let tm = 0.5 * (t0 + t1); + for sign in [1.0, -1.0] { + let (cu, cv) = (u - sign * tm, v - sign * tm); + candidates.push(line([cu + sign * t0, v], [cu + sign * t1, v])); + candidates.push(line([u, cv + sign * t0], [u, cv + sign * t1])); + } } candidates.into_iter().find(|pc| self.lifts(pc, curve, [t0, t1], exact)) } diff --git a/crates/kernel/src/sew.rs b/crates/kernel/src/sew.rs index 9ec71250f..ec6903a5c 100644 --- a/crates/kernel/src/sew.rs +++ b/crates/kernel/src/sew.rs @@ -1152,12 +1152,34 @@ pub(crate) fn assemble(parts: Parts, solid: bool) -> Result { } g }; - let forms: Vec> = edges + // A circle on a cylinder, cone, sphere or torus about its axis is labelled on that face's + // frame, so its form lies on the face's quarter grid and its pcurve there is a straight line. + let mut frame_of: Vec> = vec![None; edges.len()]; + for f in &faces { + let (b::Surface::Cylinder { frame, .. } + | b::Surface::Cone { frame, .. } + | b::Surface::Sphere { frame, .. } + | b::Surface::Torus { frame, .. }) = &f.surface + else { + continue; + }; + for u in f.loops.iter().flatten() { + if let Some(slot) = frame_of.get_mut(u.edge as usize).filter(|s| s.is_none()) { + *slot = Some(frame); + } + } + } + let labels: Vec<(b::Curve, [f64; 2])> = edges + .iter() + .zip(&frame_of) + .map(|(e, frame)| frame.and_then(|f| b::form::on_frame(&e.curve, e.interval, f, tol)).unwrap_or_else(|| (e.curve.clone(), e.interval))) + .collect(); + let forms: Vec> = labels .iter() .zip(&given_on) - .map(|(e, given)| match e.curve { + .map(|((curve, interval), given)| match curve { b::Curve::Circle { .. } | b::Curve::Ellipse { .. } if !given => { - b::form::curve(&e.curve, e.interval).ok_or_else(|| fail("an arc of more than one turn".into())).map(Some) + b::form::curve(curve, *interval).ok_or_else(|| fail("an arc of more than one turn".into())).map(Some) } _ => Ok(None), }) @@ -1300,13 +1322,13 @@ pub(crate) fn assemble(parts: Parts, solid: bool) -> Result { } let record_edges = edges .iter() - .zip(&forms) - .map(|(e, form)| { + .zip(forms.iter().zip(&labels)) + .map(|(e, (form, (label, label_interval)))| { let (nurbs, interval) = match form { Some((c, i)) => (Some(c.clone()), *i), - None => (None, e.interval), + None => (None, *label_interval), }; - b::Edge { nurbs, curve: e.curve.clone(), interval, vertices: e.vertices, tolerance: tol, uses: Vec::new() } + b::Edge { nurbs, curve: label.clone(), interval, vertices: e.vertices, tolerance: tol, uses: Vec::new() } }) .collect(); let record_vertices = vertices.iter().map(|point| b::Vertex { point: *point, tolerance: tol }).collect(); @@ -1424,7 +1446,8 @@ fn face_flux(s: &SurfaceEval, v0: f64, loops: &[Vec<(&Curve2, bool)>], field: &d let [t0, t1] = c.interval()?; let at = |k: f64| { let f = k / FLUX_PIECES as f64; - c.eval(if *forward { t0 + (t1 - t0) * f } else { t1 - (t1 - t0) * f }) + // Exactly the ends at f = 0 and 1, whatever the interval's rounding. + c.eval(if *forward { t0 * (1.0 - f) + t1 * f } else { t1 * (1.0 - f) + t0 * f }) }; for k in 0..FLUX_PIECES { let (a, m, z) = (at(k as f64)?, at(k as f64 + 0.5)?, at(k as f64 + 1.0)?);