From 7952516eb41b07e46dd13c4ee7a24f6ddcf26f29 Mon Sep 17 00:00:00 2001 From: jyviko <2501648+jyviko@users.noreply.github.com> Date: Thu, 22 Oct 2026 01:01:03 -0400 Subject: [PATCH] doc: sweeps along linked and planar curves follow the exact curves MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A sweep path through 3D sketch curves sampled every planar sketch curve in it into a 0.01 mm polyline, and took every linked 3D curve as the points its link stored, so SMLib got a many-cornered polyline (and refused a smooth one). Now: - a planar sketch curve in such a path is its exact segments (PathPiece::Segs of PathSeg::of_sketch over exact_segs); - a linked curve whose source has an exact curve keeps it: Wire::exact holds the record curves (WireCurve: schema 4 curve + interval) end to end along the wire, set with the wire when the link is resolved: an included body edge its record edge (kernel::brep_record), an included sketch curve leaving the plane its segments (kernel::sketch_record_curve). Wire::map carries them with a placement. The sweep follows them through kernel::curve_path (line, arc, ellipse as rational quadratic spans, polyline, B-spline as Bézier spans). - curves known only as points (projected onto a face, intersection and iso curves: the link resolves them on the mesh) stay points. Kernel, for the sheet and blend ports: planar_face_record (a profile face as a schema 4 sheet record with exact pcurves), smlib_sweeps::chain_curves (a segment chain as SMLib curves), body_from_record (any record into SMLib, checked), sketch_record_curve; record curves from design files are checked in curve_path. Format: pending/wire-exact-curves.rs. lib.rs (coordinator): export SpaceBezier, curve_path, edge_path, sketch_record_curve and planar_face_record from the kernel. (not built: base in progress; kernel and sketch check clean, doc not reachable) Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_017itGh5fpMEousnZ91cYcVt --- crates/doc/src/eval.rs | 65 ++++---------- .../src/format/pending/wire-exact-curves.rs | 6 ++ crates/doc/src/project.rs | 82 +++++++++++++---- crates/kernel/src/build.rs | 88 ++++++++++++++++++- crates/kernel/src/point_path.rs | 79 +++++++++++++++-- crates/kernel/src/polyhedron.rs | 2 +- crates/kernel/src/smlib_sweeps.rs | 19 ++-- crates/sketch/src/lib.rs | 2 +- crates/sketch/src/wire.rs | 85 +++++++++++++++++- 9 files changed, 347 insertions(+), 81 deletions(-) create mode 100644 crates/doc/src/format/pending/wire-exact-curves.rs diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rs index 36d5ca947..9e35624b3 100644 --- a/crates/doc/src/eval.rs +++ b/crates/doc/src/eval.rs @@ -5844,17 +5844,7 @@ fn pipe_region(vals: &BTreeMap, r: f64, wall: &Option(doc: &Document, sketch: &'a SolvedSketch, consumer: u64) -> /// A path that uses 3D sketch curves (wires), as one chain of pieces from the end nearest /// `start` (no start: the first curve runs toward the second): each drawn 3D spline as its fit -/// points (the kernel has its exact curve), every other curve as world points. `None` when the -/// path is all planar curves. +/// points (the kernel has its exact curve), each curve held exactly (a planar sketch curve, a +/// linked curve with [`solidcraft_sketch::Wire::exact`]) as its path segments, and a linked +/// curve known only as points as those points. `None` when the path is all planar curves. fn path_points(ps: &SolvedSketch, ids: &[String], start: Vec3) -> Result> { if !ids.iter().any(|id| ps.sketch.wire_index(id).is_some()) { return Ok(None); @@ -5923,20 +5914,19 @@ fn path_points(ps: &SolvedSketch, ids: &[String], start: Vec3) -> Result= 3 => kernel::PathPiece::Spline { fit: w.fit.clone(), reversed: false }, + Some(w) if !w.exact.is_empty() => { + let mut segs = Vec::new(); + for c in &w.exact { + segs.extend(kernel::curve_path(&c.curve, c.interval)?); + } + kernel::PathPiece::Segs(segs) + } w => kernel::PathPiece::Polyline(w.map(|w| w.pts.clone()).unwrap_or_default()), }); } else { let ci = ps.sketch.curve_index(id).ok_or_else(|| DocError::Unknown(format!("path curve `{id}`")))?; - let mut pts: Vec = Vec::new(); - for s in ps.sketch.segs(ci) { - for q in s.polyline(1e-2) { - let w = ps.plane.to_world(q); - if pts.last().is_none_or(|l| l.dist(w) > 1e-9) { - pts.push(w); - } - } - } - pieces.push(kernel::PathPiece::Polyline(pts)); + let segs = ps.sketch.exact_segs(ci).unwrap_or_else(|| ps.sketch.segs(ci)); + pieces.push(kernel::PathPiece::Segs(segs.iter().map(|s| kernel::PathSeg::of_sketch(&ps.plane, s)).collect())); } } // Pieces meet within the sketch's tolerance (projected curves are only that close). @@ -6022,19 +6012,7 @@ pub(crate) fn path_segments_at(ps: &SolvedSketch, ids: &[String], start: Vec3, p if let Some(profile) = profile { segs = from_profile_on_closed_path(segs, &ps.plane, profile, start); } - let n = ps.plane.normal(); - Ok(segs - .iter() - .flat_map(|s| match *s { - solidcraft_geom::Seg2::Line { a, b } => vec![kernel::PathSeg::Line { a: w(a), b: w(b) }], - solidcraft_geom::Seg2::Arc { center, sweep, .. } => { - vec![kernel::PathSeg::Arc { a: w(s.start()), center: w(center), axis: n * sweep.signum(), angle: sweep.abs() }] - } - solidcraft_geom::Seg2::Cubic { .. } | solidcraft_geom::Seg2::Conic { .. } | solidcraft_geom::Seg2::Bezier { .. } => { - vec![kernel::PathSeg::Curve { plane: ps.plane, seg: *s }] - } - }) - .collect()) + Ok(segs.iter().map(|s| kernel::PathSeg::of_sketch(&ps.plane, s)).collect()) } /// A closed chain `segs` (in the plane `path`) begun where `profile`'s plane crosses it nearest @@ -6342,7 +6320,7 @@ fn seg_len(s: &kernel::PathSeg) -> f64 { kernel::PathSeg::Line { a, b } => (b - a).len(), kernel::PathSeg::Arc { a, center, angle, .. } => (a - center).len() * angle.abs(), // Patterns flatten their paths; a curve left is measured along its chord. - kernel::PathSeg::Curve { .. } | kernel::PathSeg::Cubic { .. } => s.start().dist(s.end()), + kernel::PathSeg::Curve { .. } | kernel::PathSeg::Bezier(_) => s.start().dist(s.end()), } } @@ -6366,7 +6344,7 @@ fn seg_at(s: &kernel::PathSeg, t: f64) -> (Vec3, Vec3) { let v = rotate_vec(a - center, k, s * t / r); (center + v, k.cross(v).normalized().unwrap_or(Vec3::X) * s) } - kernel::PathSeg::Curve { .. } | kernel::PathSeg::Cubic { .. } => { + kernel::PathSeg::Curve { .. } | kernel::PathSeg::Bezier(_) => { let (a, b) = (s.start(), s.end()); let d = (b - a).normalized().unwrap_or(Vec3::X); (a + d * t, d) @@ -6375,16 +6353,7 @@ fn seg_at(s: &kernel::PathSeg, t: f64) -> (Vec3, Vec3) { } fn reverse_seg(s: &kernel::PathSeg) -> kernel::PathSeg { - match *s { - kernel::PathSeg::Line { a, b } => kernel::PathSeg::Line { a: b, b: a }, - kernel::PathSeg::Arc { a, center, axis, angle } => { - let k = axis.normalized().unwrap_or(Vec3::Z); - let end = center + rotate_vec(a - center, k, angle); - kernel::PathSeg::Arc { a: end, center, axis: k * -1.0, angle } - } - kernel::PathSeg::Curve { plane, seg } => kernel::PathSeg::Curve { plane, seg: seg.reversed() }, - kernel::PathSeg::Cubic { p: [a, b, c, d] } => kernel::PathSeg::Cubic { p: [d, c, b, a] }, - } + s.reversed() } /// Point and tangent at arc length `d` along a chain (clamped to its ends). diff --git a/crates/doc/src/format/pending/wire-exact-curves.rs b/crates/doc/src/format/pending/wire-exact-curves.rs new file mode 100644 index 000000000..40ae67d2b --- /dev/null +++ b/crates/doc/src/format/pending/wire-exact-curves.rs @@ -0,0 +1,6 @@ +//! A linked 3D sketch curve (an included edge or an included sketch curve that leaves the sketch +//! plane) saves its exact geometry with its points: `wires[].exact`, the record curves (schema 4 +//! curve records with their intervals) end to end along the curve, so a sweep along it follows +//! the curve itself rather than its points. An older design has none and gets them when its +//! links are next resolved; until then such a curve is followed as its points. The last release +//! refuses a design with this change (the newer format number). diff --git a/crates/doc/src/project.rs b/crates/doc/src/project.rs index fa590979d..525017597 100644 --- a/crates/doc/src/project.rs +++ b/crates/doc/src/project.rs @@ -13,7 +13,7 @@ use std::collections::BTreeMap; use solidcraft_geom::{Mesh, Plane, Seg2, Vec2, Vec3}; -use solidcraft_sketch::{CurveKind, LinkGeom, LinkKind, LinkSource, Sketch}; +use solidcraft_sketch::{CurveKind, LinkGeom, LinkKind, LinkSource, Sketch, WireCurve}; use crate::eval::ModelState; use crate::expr::Value; @@ -33,6 +33,9 @@ pub struct Resolved { pub geom: Vec, /// 3D curves (world coordinates). pub wires: Vec>, + /// Each wire's exact curve where its source has one (an included edge or sketch curve), + /// one list per wire, empty for a curve known only as points ([`solidcraft_sketch::Wire::exact`]). + pub exact: Vec>, pub source: LinkSource, /// The reference was not exactly where it was and was re-found on the nearest geometry. pub moved: bool, @@ -108,6 +111,7 @@ fn resolve_uncached( let mut edge_index = None; let mut source = src.clone(); let mut wires: Vec> = Vec::new(); + let mut exact: Vec> = Vec::new(); let geom = match src { LinkSource::Edge { body, at } => { let (bi, mesh) = body_mesh(st, body, *at)?; @@ -120,8 +124,9 @@ fn resolve_uncached( let name = st.bodies.get(bi).map(|b| b.name.clone()).unwrap_or_else(|| body.clone()); source = LinkSource::Edge { body: name, at: q }; edge_index = Some(e); - let exact = st.bodies.get(bi).and_then(|b| exact_edges(b, plane, &[e]).pop().flatten()); - edge_geom(plane, kind, exact, mesh.edges.get(e).cloned().unwrap_or_default(), &mut wires) + let planar = st.bodies.get(bi).and_then(|b| exact_edges(b, plane, &[e]).pop().flatten()); + let pts = mesh.edges.get(e).cloned().unwrap_or_default(); + edge_geom(plane, kind, planar, (pts, || edge_curves(st.bodies.get(bi), e)), &mut wires, &mut exact) } LinkSource::Face { body, at } => { let (bi, mesh) = body_mesh(st, body, *at)?; @@ -182,6 +187,7 @@ fn resolve_uncached( let pts: Vec = ss.sketch.polyline(ci).iter().map(|p| ss.plane.to_world(*p)).collect(); if off_plane(plane, &pts) { wires.push(pts); + exact.push(sketch_curves(ss, ci)); Vec::new() } else { project_sketch_curve(&ss.sketch, &ss.plane, ci, plane) @@ -203,12 +209,14 @@ fn resolve_uncached( let name = st.bodies.get(bi).map(|b| b.name.clone()).unwrap_or_else(|| body.clone()); source = LinkSource::OnSurface { sketch: *sketch, curve: curve.clone(), body: name, at: q }; wires = crate::project3d::onto_face(&mesh, f, &pts, plane.normal()); + exact = vec![Vec::new(); wires.len()]; Vec::new() } LinkSource::Intersection { a, b } => { let (ma, fa) = crate::project3d::mesh_of(st, a).ok_or_else(|| lost(&a.describe()))?; let (mb, fb) = crate::project3d::mesh_of(st, b).ok_or_else(|| lost(&b.describe()))?; wires = crate::project3d::mesh_intersection(&ma, fa, &mb, fb); + exact = vec![Vec::new(); wires.len()]; Vec::new() } LinkSource::Iso { body, at, dir } => { @@ -221,6 +229,7 @@ fn resolve_uncached( let name = st.bodies.get(bi).map(|b| b.name.clone()).unwrap_or_else(|| body.clone()); source = LinkSource::Iso { body: name, at: q, dir: dir.clone() }; wires = crate::project3d::iso_curve(&mesh, f, q, dir); + exact = vec![Vec::new(); wires.len()]; Vec::new() } LinkSource::Spun { body, origin, dir } => { @@ -275,7 +284,7 @@ fn resolve_uncached( if geom.is_empty() && wires.is_empty() { return Err(DocError::Invalid(format!("the {} projects to nothing on this sketch plane", src.describe()))); } - Ok(Resolved { geom: merge_split_circles(geom), wires, source, moved, face_index, edge_index }) + Ok(Resolved { geom: merge_split_circles(geom), wires, exact, source, moved, face_index, edge_index }) } /// Whether a curve (world points) leaves the sketch plane: included, it then stays 3D. @@ -285,19 +294,51 @@ fn off_plane(plane: &Plane, pts: &[Vec3]) -> bool { } /// What a body edge (its `exact` curve when read, and its polyline `pts`) gives a sketch: its -/// section with the sketch plane, itself as a 3D curve (into `wires`) when it is included and -/// leaves the plane, else its projection (the exact curve, or the polyline fitted). -fn edge_geom(plane: &Plane, kind: LinkKind, exact: Option>, pts: Vec, wires: &mut Vec>) -> Vec { +/// section with the sketch plane, itself as a 3D curve (its points into `wires`, its exact +/// curve into `exact`) when it is included and leaves the plane, else its projection (the exact +/// planar curve `planar`, or the polyline fitted). +fn edge_geom( + plane: &Plane, + kind: LinkKind, + planar: Option>, + (pts, curves): (Vec, impl FnOnce() -> Vec), + wires: &mut Vec>, + exact: &mut Vec>, +) -> Vec { match kind { LinkKind::Intersect => section_of_polyline(plane, &pts), LinkKind::Include if off_plane(plane, &pts) => { wires.push(pts); + exact.push(curves()); Vec::new() } - _ => exact.unwrap_or_else(|| fit_world(plane, &pts)), + _ => planar.unwrap_or_else(|| fit_world(plane, &pts)), } } +/// Edge `e` of `body` (its index in the body's edge order) as its exact curve from the body's +/// record; none for a mesh body or an intersection curve the record holds no curve for. +fn edge_curves(body: Option<&crate::ModelBody>, e: usize) -> Vec { + let Some(body) = body.filter(|b| !b.body.is_mesh()) else { return Vec::new() }; + let Ok(record) = crate::kernel::brep_record(&body.body) else { return Vec::new() }; + record + .edges + .get(e) + .filter(|edge| !matches!(edge.curve, solidcraft_geom::brep::Curve::SurfaceIntersection { .. })) + .map(|edge| vec![WireCurve { curve: edge.curve.clone(), interval: edge.interval }]) + .unwrap_or_default() +} + +/// Curve `ci` of the solved sketch `ss` as its exact pieces in space, in the order its polyline +/// runs; none where a piece has no record curve. +fn sketch_curves(ss: &crate::eval::SolvedSketch, ci: usize) -> Vec { + let segs = ss.sketch.exact_segs(ci).unwrap_or_else(|| ss.sketch.segs(ci)); + segs.iter() + .map(|s| crate::kernel::sketch_record_curve(&ss.plane, s).map(|(curve, interval)| WireCurve { curve, interval })) + .collect::>() + .unwrap_or_default() +} + /// Edges `edges` of `body` (indices into its mesh's `edges`) on `plane` as their exact curves: /// lines, circles and arcs, and the Bézier pieces of a free-form curve. `None` for an edge that /// doesn't lie in a plane parallel to `plane` or isn't read exactly (a mesh body's): it is @@ -375,14 +416,14 @@ fn resolve_named_edge(st: &ModelState, plane: &Plane, kind: LinkKind, body: &str .filter_map(|w| Some(closest_on_segment(near, *w.first()?, *w.get(1)?))) .min_by(|a, b| a.dist(near).total_cmp(&b.dist(near))) .ok_or_else(|| lost("named projection edge"))?; - let mut wires = Vec::new(); - let exact = exact_edges(target, plane, &[index]).pop().flatten(); - let geom = edge_geom(plane, kind, exact, pts, &mut wires); + let (mut wires, mut exact) = (Vec::new(), Vec::new()); + let planar = exact_edges(target, plane, &[index]).pop().flatten(); + let geom = edge_geom(plane, kind, planar, (pts, || edge_curves(Some(target), index)), &mut wires, &mut exact); if geom.is_empty() && wires.is_empty() { return Err(DocError::Invalid("named edge projects to nothing on this sketch plane".into())); } let source = LinkSource::Edge { body: body.into(), at }; - Ok(Resolved { geom: merge_split_circles(geom), wires, source, moved: false, face_index: None, edge_index: Some(index) }) + Ok(Resolved { geom: merge_split_circles(geom), wires, exact, source, moved: false, face_index: None, edge_index: Some(index) }) } fn resolve_named_face(st: &ModelState, plane: &Plane, kind: LinkKind, body: &str, index: usize, at: Vec3) -> Result { @@ -403,7 +444,15 @@ fn resolve_named_face(st: &ModelState, plane: &Plane, kind: LinkKind, body: &str if geom.is_empty() { return Err(DocError::Invalid("named face projects to nothing on this sketch plane".into())); } - Ok(Resolved { geom, wires: Vec::new(), source: LinkSource::Face { body: body.into(), at }, moved: false, face_index, edge_index: None }) + Ok(Resolved { + geom, + wires: Vec::new(), + exact: Vec::new(), + source: LinkSource::Face { body: body.into(), at }, + moved: false, + face_index, + edge_index: None, + }) } fn projection_face_edges(body: &crate::ModelBody, mesh: &Mesh, index: u32, plane: &Plane) -> Result> { @@ -484,6 +533,7 @@ pub fn resolve_face_indices(st: &ModelState, plane: &Plane, kind: LinkKind, body Ok(Resolved { geom: merge_split_circles(geometry), wires: Vec::new(), + exact: Vec::new(), source: LinkSource::Face { body: body.name.clone(), at: point }, moved: false, face_index: if indices.len() == 1 { indices.first().copied() } else { None }, @@ -663,7 +713,7 @@ fn refresh_links_in( if geom.is_empty() { return Err(DocError::Invalid(format!("the {} makes no outline", source.describe()))); } - Ok(Resolved { geom, wires: Vec::new(), source: source.clone(), moved: false, face_index: None, edge_index: None }) + Ok(Resolved { geom, wires: Vec::new(), exact: Vec::new(), source: source.clone(), moved: false, face_index: None, edge_index: None }) }) } else if l.auto_face { anchor @@ -690,7 +740,9 @@ fn refresh_links_in( link.edge_name = Some(name); } sk.set_link_source(&l.id, r.source); - let _ = sk.set_link_wires(&l.id, &r.wires); + if let Err(e) = sk.set_link_wires(&l.id, &r.wires).and_then(|()| sk.set_link_wire_curves(&l.id, &r.exact)) { + warn.push(format!("projected {}: {e}", l.source.describe())); + } // Words built from text parameters change shape when the parameters do: that // rebuild is the text following them, not a reference that changed under it. let words_follow = matches!(&l.source, LinkSource::Text { exprs, .. } if exprs.text.is_some()); diff --git a/crates/kernel/src/build.rs b/crates/kernel/src/build.rs index eab371781..416878923 100644 --- a/crates/kernel/src/build.rs +++ b/crates/kernel/src/build.rs @@ -920,6 +920,90 @@ fn smlib_tapered(plane: &Plane, region: &Region2, from: f64, to: f64, foot: f64, crate::smlib_sweeps::extrude(plane, &crate::smlib_sweeps::pieces([&bottom]), Some(region), from * sign, to - from, sign, draft) } +/// A planar region on `plane` as the schema 4 record of one face (an open sheet): the plane's +/// own axes as its parameters (its natural normal the sketch's), the outer loop +/// counter-clockwise and the holes clockwise, each sketch segment one edge of its exact record +/// curve ([`crate::point_path::sketch_record_curve`]) with its exact pcurve on the plane. The record +/// equivalent of a profile face: SMLib takes it with `Brep::from_record`. +pub fn planar_face_record(plane: &Plane, r: &Region2) -> Result { + use solidcraft_geom::brep::{self as rec, pcurve}; + if !frame_ok(plane) { + return Err(KernelError::Invalid("the face's plane is not finite and orthonormal".into())); + } + region_ok(r)?; + let region = oriented(r)?; + let tolerance = 1e-7; + let d = |v: Vec3| [v.x, v.y, v.z]; + let surface = rec::Surface::Plane { origin: d(plane.origin), u_axis: d(plane.x), v_axis: d(plane.y) }; + let bad = |what: &str| KernelError::Invalid(format!("profile {what}")); + // Edges and vertices numbered as the face's loops first meet them. + let mut edges: Vec = Vec::new(); + let mut vertices: Vec = Vec::new(); + let mut loops: Vec> = Vec::new(); + let (mut lo, mut hi) = ([f64::INFINITY; 2], [f64::NEG_INFINITY; 2]); + for (li, l) in region.loops().enumerate() { + let segs = &l.lp.segs; + let first = u32::try_from(vertices.len()).map_err(|_| bad("size"))?; + let mut ids = Vec::with_capacity(segs.len()); + for (k, s) in segs.iter().enumerate() { + let (curve, interval) = crate::point_path::sketch_record_curve(plane, s).ok_or_else(|| bad("curve"))?; + let start = u32::try_from(vertices.len()).map_err(|_| bad("size"))?; + vertices.push(rec::Vertex { point: d(plane.to_world(s.start())), tolerance }); + let end = if k + 1 == segs.len() { first } else { start + 1 }; + let e = u32::try_from(edges.len()).map_err(|_| bad("size"))?; + let (li, k) = (u32::try_from(li).map_err(|_| bad("size"))?, u32::try_from(k).map_err(|_| bad("size"))?); + edges.push(rec::Edge { + curve, + interval, + vertices: [start, end], + tolerance, + uses: vec![rec::EdgeUseRef { face: 0, r#loop: li, position: k, upper: false }], + }); + ids.push(e); + for q in s.polyline(tolerance) { + for (i, x) in [q.x, q.y].into_iter().enumerate() { + if let (Some(a), Some(b)) = (lo.get_mut(i), hi.get_mut(i)) { + *a = a.min(x); + *b = b.max(x); + } + } + } + } + loops.push(ids); + } + let uses: Vec>> = loops + .iter() + .map(|ids| { + ids.iter() + .filter_map(|&e| { + let edge = edges.get(e as usize)?; + Some(pcurve::EdgeUse { edge: e, curve: &edge.curve, interval: edge.interval, forward: true, tolerance, given: None }) + }) + .collect() + }) + .collect(); + let pcurves = pcurve::pcurves(&surface, &uses, tolerance).map_err(|e| KernelError::Failed(format!("profile pcurves: {e}")))?; + let face_loops = loops + .iter() + .zip(pcurves) + .map(|(ids, pcs)| rec::Loop::Edges { + edges: ids.iter().zip(pcs).map(|(&edge, pcurve)| rec::OrientedEdge { edge, forward: true, pcurve }).collect(), + }) + .collect(); + let pad = tolerance * 10.0; + let brep = rec::Brep { + version: rec::VERSION, + tolerance, + regions: vec![rec::Region { shells: vec![0], void: false }], + shells: vec![rec::Shell::Faces { faces: vec![rec::OrientedFace { face: 0, forward: true }], wires: vec![] }], + faces: vec![rec::Face { surface, domain: [[lo[0] - pad, hi[0] + pad], [lo[1] - pad, hi[1] + pad]], loops: face_loops }], + edges, + vertices, + }; + brep.validate().map_err(|e| KernelError::Failed(format!("profile face: {e}")))?; + Ok(brep) +} + /// Ruled loft through two or more planar sections (outer loops only). The sections and the /// same sections in reverse order give the same body. pub fn loft(sections: &[(Plane, Loop2)]) -> Result { @@ -1377,7 +1461,9 @@ impl PathSeg { let w = |p: Vec2| plane.to_world(p); match *s { Seg2::Line { a, b } => PathSeg::Line { a: w(a), b: w(b) }, - Seg2::Arc { center, sweep, .. } => PathSeg::Arc { a: w(s.start()), center: w(center), axis: plane.normal() * sweep.signum(), angle: sweep.abs() }, + Seg2::Arc { center, sweep, .. } => { + PathSeg::Arc { a: w(s.start()), center: w(center), axis: plane.normal() * sweep.signum(), angle: sweep.abs() } + } Seg2::Cubic { .. } | Seg2::Conic { .. } | Seg2::Bezier { .. } => PathSeg::Curve { plane: *plane, seg: *s }, } } diff --git a/crates/kernel/src/point_path.rs b/crates/kernel/src/point_path.rs index db763a615..5953b3de0 100644 --- a/crates/kernel/src/point_path.rs +++ b/crates/kernel/src/point_path.rs @@ -75,7 +75,9 @@ impl PathPiece { if spans.is_empty() { return Ok(None); } - let seg = |p: [Vec3; 4]| SpaceBezier::cubic(p).map(PathSeg::Bezier).ok_or_else(|| KernelError::Invalid("the 3D sketch spline is not finite".into())); + let seg = |p: [Vec3; 4]| { + SpaceBezier::cubic(p).map(PathSeg::Bezier).ok_or_else(|| KernelError::Invalid("the 3D sketch spline is not finite".into())) + }; Ok(Some(if *reversed { spans.into_iter().rev().map(|[a, b, c, d]| seg([d, c, b, a])).collect::>()? } else { @@ -153,13 +155,30 @@ pub fn edge_path(body: &Body, edge: usize) -> Result> { curve_path(&e.curve, e.interval) } -/// The record curve `c` on `[t0, t1]` as path segments ([`edge_path`]). -pub(crate) fn curve_path(c: &brep::Curve, [t0, t1]: [f64; 2]) -> Result> { - let bad = |what: &str| KernelError::Invalid(format!("the edge's {what} does not evaluate")); - if !(t0.is_finite() && t1.is_finite() && t0 < t1) { +/// Most control points a record curve given to [`curve_path`] may have. +const MAX_CURVE_POINTS: usize = 100_000; + +/// The record curve `c` on `[t0, t1]` as path segments ([`edge_path`]); the numbers are checked +/// first (they may come from a design file). +pub fn curve_path(c: &brep::Curve, [t0, t1]: [f64; 2]) -> Result> { + let bad = |what: &str| KernelError::Invalid(format!("the curve's {what} does not evaluate")); + if !(t0.is_finite() && t1.is_finite() && t0 < t1 && t0.abs() < 1e9 && t1.abs() < 1e9) { return Err(bad("interval")); } let v = |q: [f64; 3]| Vec3::new(q[0], q[1], q[2]); + let frame_ok = |f: &brep::Frame| { + let (x, y) = (v(f.x_axis), v(f.y_axis)); + v(f.origin).is_finite() && (x.len() - 1.0).abs() < 1e-6 && (y.len() - 1.0).abs() < 1e-6 && x.dot(y).abs() < 1e-6 + }; + let finite = |pts: &[[f64; 3]]| pts.len() <= MAX_CURVE_POINTS && pts.iter().all(|q| v(*q).is_finite()); + match c { + brep::Curve::Line { start, end } if !finite(&[*start, *end]) => return Err(bad("line")), + brep::Curve::Circle { frame, radius } if !(frame_ok(frame) && radius.is_finite() && *radius > 0.0) => return Err(bad("circle")), + brep::Curve::Ellipse { frame, radii } if !(frame_ok(frame) && radii.iter().all(|r| r.is_finite() && *r > 0.0)) => return Err(bad("ellipse")), + brep::Curve::Polyline { points } | brep::Curve::Spline { points, .. } if !finite(points) => return Err(bad("points")), + brep::Curve::RationalSpline { homogeneous, .. } if homogeneous.len() > MAX_CURVE_POINTS => return Err(bad("points")), + _ => {} + } let out = match c { brep::Curve::Line { start, end } => { let (s, e) = (v(*start), v(*end)); @@ -184,7 +203,8 @@ pub(crate) fn curve_path(c: &brep::Curve, [t0, t1]: [f64; 2]) -> Result>()? @@ -218,6 +238,53 @@ pub(crate) fn curve_path(c: &brep::Curve, [t0, t1]: [f64; 2]) -> Result Option<(brep::Curve, [f64; 2])> { + use solidcraft_geom::Seg2; + let w = |p: solidcraft_geom::Vec2| { + let q = plane.to_world(p); + [q.x, q.y, q.z] + }; + let d = |v: Vec3| [v.x, v.y, v.z]; + let bezier = |pts: &[solidcraft_geom::Vec2]| { + let n = pts.len().checked_sub(1)?; + let knots = std::iter::repeat_n(0.0, n + 1).chain(std::iter::repeat_n(1.0, n + 1)).collect(); + Some((brep::Curve::Spline { knots, points: pts.iter().map(|p| w(*p)).collect() }, [0.0, 1.0])) + }; + let out = match *s { + Seg2::Line { a, b } => (brep::Curve::Line { start: w(a), end: w(b) }, [0.0, 1.0]), + Seg2::Arc { center, radius, start, sweep } => { + let (y, t0) = if sweep >= 0.0 { (plane.y, start) } else { (plane.y * -1.0, -start) }; + let frame = brep::Frame { origin: w(center), x_axis: d(plane.x), y_axis: d(y) }; + (brep::Curve::Circle { frame, radius }, [t0, t0 + sweep.abs()]) + } + Seg2::Cubic { p0, p1, p2, p3 } => bezier(&[p0, p1, p2, p3])?, + Seg2::Bezier { n, p } => bezier(p.get(..=usize::from(n))?)?, + Seg2::Conic { a, apex, b, w: wt } => { + let h = |p: solidcraft_geom::Vec2, k: f64| { + let q = w(p); + [q[0] * k, q[1] * k, q[2] * k, k] + }; + ( + brep::Curve::RationalSpline { knots: vec![0.0, 0.0, 0.0, 1.0, 1.0, 1.0], homogeneous: vec![h(a, 1.0), h(apex, wt), h(b, 1.0)] }, + [0.0, 1.0], + ) + } + }; + let finite = |q: &[f64]| q.iter().all(|x| x.is_finite()); + let ok = match &out.0 { + brep::Curve::Line { start, end } => finite(start) && finite(end), + brep::Curve::Circle { frame, radius } => finite(&frame.origin) && radius.is_finite() && *radius > 0.0, + brep::Curve::Spline { points, .. } => points.iter().all(|q| finite(q)), + brep::Curve::RationalSpline { homogeneous, .. } => homogeneous.iter().all(|q| finite(q) && q[3] > 0.0), + _ => false, + }; + (ok && out.1.iter().all(|t| t.is_finite())).then_some(out) +} + /// The B-spline (homogeneous `ctrl` on `knots`) on `[t0, t1]` as its Bézier spans, one per knot /// span: each the piece of the spline between two neighbouring knots ([`segment`]), exactly. fn spline_spans(knots: &[f64], ctrl: &[HPoint], t0: f64, t1: f64) -> Result> { diff --git a/crates/kernel/src/polyhedron.rs b/crates/kernel/src/polyhedron.rs index 603f1ca01..153c43260 100644 --- a/crates/kernel/src/polyhedron.rs +++ b/crates/kernel/src/polyhedron.rs @@ -77,7 +77,7 @@ fn combinatorics(hs: &[HalfSpace]) -> Result<(Vec, Vec<(usize, Vec) /// The convex polyhedron bounded by the half-spaces. pub fn convex_polyhedron(hs: &[HalfSpace]) -> Result { let (verts, faces) = combinatorics(hs)?; - crate::smlib_sweeps::solid_from_record(&polyhedron_record(hs, &verts, &faces)?, "polyhedron") + crate::smlib_sweeps::body_from_record(&polyhedron_record(hs, &verts, &faces)?, "polyhedron") } /// The record of the closed polyhedron with corners `verts` whose faces are `faces` (the diff --git a/crates/kernel/src/smlib_sweeps.rs b/crates/kernel/src/smlib_sweeps.rs index 75158a617..31b66347b 100644 --- a/crates/kernel/src/smlib_sweeps.rs +++ b/crates/kernel/src/smlib_sweeps.rs @@ -71,7 +71,7 @@ pub(crate) struct Draft { } #[cfg(feature = "smlib")] -pub(crate) use imp::{extrude, loft, loft_rails, loft_to_point, revolve, screw, solid_from_record, sphere, sweep, sweep_controlled}; +pub(crate) use imp::{body_from_record, extrude, loft, loft_rails, loft_to_point, revolve, screw, sphere, sweep, sweep_controlled}; /// The error of an SMLib operation in a build without SMLib. #[cfg(not(feature = "smlib"))] @@ -83,7 +83,7 @@ pub(crate) fn not_built() -> KernelError { mod stubs { use super::*; - pub(crate) fn solid_from_record(_: &solidcraft_geom::brep::Brep, _: &str) -> Result { + pub(crate) fn body_from_record(_: &solidcraft_geom::brep::Brep, _: &str) -> Result { Err(not_built()) } pub(crate) fn sphere(_: Vec3, _: f64) -> Result { @@ -115,7 +115,7 @@ mod stubs { } } #[cfg(not(feature = "smlib"))] -pub(crate) use stubs::{extrude, loft, loft_rails, loft_to_point, revolve, screw, solid_from_record, sphere, sweep, sweep_controlled}; +pub(crate) use stubs::{body_from_record, extrude, loft, loft_rails, loft_to_point, revolve, screw, sphere, sweep, sweep_controlled}; /// Refuses what no SMLib sweep does, before any work. pub(crate) fn refuse(what: &str) -> KernelError { @@ -183,6 +183,13 @@ mod imp { pieces.iter().map(|x| curve(plane, &x.seg)).collect() } + /// A chain of sketch segments on `plane` as SMLib's curves, one each, exactly (lines, arcs, + /// Béziers and conics as NURBS): what SMLib's sweeps take as a profile or a path. + #[allow(dead_code)] // For the sheet builders, which still build their own wires. + pub(crate) fn chain_curves(plane: &Plane, segs: &[Seg2]) -> Result> { + segs.iter().map(|s| curve(plane, s)).collect() + } + /// The kernel body of an SMLib result SMLib's own check finds valid. fn body_of(brep: &Brep, what: &str) -> Result { let check = brep.check(CheckLevel::All).map_err(|e| failed(what, e))?; @@ -192,9 +199,9 @@ mod imp { crate::native::body_from_smlib(brep) } - /// The solid a schema 4 record describes, taken by SMLib as a modeller's own record (no - /// healing) and checked there. - pub(crate) fn solid_from_record(record: &solidcraft_geom::brep::Brep, what: &str) -> Result { + /// The body (a solid or a sheet) a schema 4 record describes, taken by SMLib as a + /// modeller's own record (no healing) and checked there. + pub(crate) fn body_from_record(record: &solidcraft_geom::brep::Brep, what: &str) -> Result { let brep = Brep::from_record(record, true).map_err(|e| failed(what, e))?; body_of(&brep, what) } diff --git a/crates/sketch/src/lib.rs b/crates/sketch/src/lib.rs index f30136b10..91d2ec79c 100644 --- a/crates/sketch/src/lib.rs +++ b/crates/sketch/src/lib.rs @@ -72,7 +72,7 @@ pub use solver::{ }; pub use text::{MAX_TEXT_CHARS, TextAlign, TextMetrics, TextStyle, text_geometry, text_geometry_in, text_geometry_styled}; pub use thin::{MAX_THIN_SEGMENTS, thin_wall_regions}; -pub use wire::{MAX_FIT_POINTS, MAX_WIRE_POINTS, Wire, WireArc, WireSpace, arc_from_3_points, arc_polyline, arc_sweep, fit_polyline}; +pub use wire::{MAX_FIT_POINTS, MAX_WIRE_POINTS, Wire, WireArc, WireCurve, WireSpace, arc_from_3_points, arc_polyline, arc_sweep, fit_polyline}; #[cfg(test)] mod circle_edge_tests; diff --git a/crates/sketch/src/wire.rs b/crates/sketch/src/wire.rs index a701724b7..efd903bdb 100644 --- a/crates/sketch/src/wire.rs +++ b/crates/sketch/src/wire.rs @@ -62,6 +62,70 @@ pub struct Wire { /// are its three defining points (start, through, end) and whose `pts` are its samples. #[serde(default, skip_serializing_if = "Option::is_none")] pub arc: Option, + /// A linked curve's exact geometry where its source has one (an included edge or sketch + /// curve): record curves end to end along `pts`, in `space` coordinates. Empty for a curve + /// known only as its points (projected onto a face, intersection and iso curves). Set when + /// the link is resolved, with `pts`. + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub exact: Vec, +} + +/// One exact piece of a 3D sketch curve ([`Wire::exact`]): a record curve on its interval. +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +pub struct WireCurve { + pub curve: solidcraft_geom::brep::Curve, + pub interval: [f64; 2], +} + +impl WireCurve { + /// The piece carried by the rigid motion `point` of points and `vector` of directions (a + /// placement). `None` for an intersection curve, whose surfaces are not carried here. + pub fn mapped(&self, point: &impl Fn(Vec3) -> Vec3, vector: &impl Fn(Vec3) -> Vec3) -> Option { + use solidcraft_geom::brep::{Curve, Frame}; + let a = |q: [f64; 3]| Vec3::new(q[0], q[1], q[2]); + let b = |v: Vec3| [v.x, v.y, v.z]; + let p = |q: [f64; 3]| b(point(a(q))); + let frame = |f: &Frame| Frame { origin: p(f.origin), x_axis: b(vector(a(f.x_axis))), y_axis: b(vector(a(f.y_axis))) }; + let curve = match &self.curve { + Curve::Line { start, end } => Curve::Line { start: p(*start), end: p(*end) }, + Curve::Circle { frame: f, radius } => Curve::Circle { frame: frame(f), radius: *radius }, + Curve::Ellipse { frame: f, radii } => Curve::Ellipse { frame: frame(f), radii: *radii }, + Curve::Polyline { points } => Curve::Polyline { points: points.iter().map(|q| p(*q)).collect() }, + Curve::Spline { knots, points } => Curve::Spline { knots: knots.clone(), points: points.iter().map(|q| p(*q)).collect() }, + Curve::RationalSpline { knots, homogeneous } => Curve::RationalSpline { + knots: knots.clone(), + homogeneous: homogeneous + .iter() + .map(|h| { + let q = point(a([h[0], h[1], h[2]]) * (1.0 / h[3])); + [q.x * h[3], q.y * h[3], q.z * h[3], h[3]] + }) + .collect(), + }, + Curve::SurfaceIntersection { .. } => return None, + }; + Some(WireCurve { curve, interval: self.interval }) + } +} + +impl Wire { + /// The wire carried by the rigid motion `point` of points and `vector` of directions: its + /// points, fit points and exact curves (dropped where one cannot be carried, leaving the + /// points). + pub fn map(&mut self, point: impl Fn(Vec3) -> Vec3, vector: impl Fn(Vec3) -> Vec3) { + for q in self.pts.iter_mut().chain(&mut self.fit) { + *q = point(*q); + } + if let Some(arc) = &mut self.arc { + let normal = vector(arc.normal); + arc.center = point(arc.center); + arc.start = point(arc.start); + arc.end = point(arc.end); + arc.normal = normal.normalized().unwrap_or(arc.normal); + arc.radius = arc.center.dist(arc.start); + } + self.exact = self.exact.iter().map(|c| c.mapped(&point, &vector)).collect::>().unwrap_or_default(); + } } /// Most fit points of a drawn 3D curve. @@ -271,7 +335,22 @@ impl Sketch { Some(o) => o.clone(), None => self.fresh("w")?, }; - self.wires.push(Wire { id: wid, pts, space: WireSpace::Component, link: Some(id.to_string()), fit: Vec::new(), arc: None }); + self.wires.push(Wire { id: wid, pts, space: WireSpace::Component, link: Some(id.to_string()), fit: Vec::new(), arc: None, exact: Vec::new() }); + } + Ok(()) + } + + /// Give a link's wires their exact curves ([`Wire::exact`]), one list per wire in the order + /// [`Self::set_link_wires`] took them (an empty list: known only as points). + pub fn set_link_wire_curves(&mut self, id: &str, exact: &[Vec]) -> Result<()> { + let wires = self.link_wires(id); + if wires.len() != exact.len() { + return Err(SketchError::Invalid(format!("link {id} has {} 3D curves, not {}", wires.len(), exact.len()))); + } + for (i, curves) in wires.into_iter().zip(exact) { + if let Some(w) = self.wires.get_mut(i) { + w.exact = curves.clone(); + } } Ok(()) } @@ -286,7 +365,7 @@ impl Sketch { let pts = drawn_polyline(fit)?; self.wire_budget(None, 1, pts.len() + fit.len())?; let id = self.fresh(if fit.len() == 1 { "q" } else { "w" })?; - self.wires.push(Wire { id: id.clone(), pts, space, link: None, fit: fit.to_vec(), arc: None }); + self.wires.push(Wire { id: id.clone(), pts, space, link: None, fit: fit.to_vec(), arc: None, exact: Vec::new() }); Ok(id) } @@ -306,7 +385,7 @@ impl Sketch { let pts = arc_polyline(&arc, ARC_TOL); self.wire_budget(None, 1, pts.len() + fit.len())?; let id = self.fresh("w")?; - self.wires.push(Wire { id: id.clone(), pts, space, link: None, fit: fit.to_vec(), arc: Some(arc) }); + self.wires.push(Wire { id: id.clone(), pts, space, link: None, fit: fit.to_vec(), arc: Some(arc), exact: Vec::new() }); Ok(id) }