diff --git a/crates/kernel/src/build.rs b/crates/kernel/src/build.rs index 54bd2f9c3..2b0627046 100644 --- a/crates/kernel/src/build.rs +++ b/crates/kernel/src/build.rs @@ -1240,15 +1240,6 @@ fn smlib_sweep(plane: &Plane, region: &Region2, path: &[PathSeg], ctl: &crate::S if path.iter().any(|s| s.tangents().is_none()) { return Err(KernelError::Invalid("a path segment has no direction".into())); } - let controlled = ctl.varies() || matches!(ctl.orientation, crate::SweepOrientation::Direction(_)); - if controlled { - let ends: Vec<(Vec3, Vec3)> = path.iter().filter_map(PathSeg::tangents).collect(); - if ends.windows(2).any(|w| w[0].1.dot(w[1].0) < (1e-3f64).cos()) { - return Err(crate::smlib_sweeps::refuse( - "sweep with a twist, an end scale, guide rails or an orientation direction along a path with corners", - )); - } - } let translate = match ctl.orientation { _ if ctl.varies() => return crate::smlib_sweeps::sweep_controlled(plane, &oriented(region)?, path, ctl), crate::SweepOrientation::Perpendicular => false, diff --git a/crates/kernel/src/smlib_sweeps.rs b/crates/kernel/src/smlib_sweeps.rs index 72074cc5f..7abc8b008 100644 --- a/crates/kernel/src/smlib_sweeps.rs +++ b/crates/kernel/src/smlib_sweeps.rs @@ -703,20 +703,13 @@ mod imp { // first meet in a mitre too. let closed = end.dist(start) <= 1e-6; let closing = (closed && last_t.dot(first_t) < (1e-3f64).cos()).then_some(first_t); - let mitre = |t1: Vec3, t2: Vec3| -> Result<(Vec3, f64)> { - let turn = t1.dot(t2).clamp(-1.0, 1.0).acos(); - if turn > std::f64::consts::PI - 1e-3 { - return Err(KernelError::Invalid("the path turns back on itself at a corner".into())); - } - Ok(((t1 + t2).normalized().ok_or_else(|| KernelError::Invalid("path corner".into()))?, turn)) - }; let mut pose = *plane; let mut body: Option = None; let mut inside = Vec::new(); // The mitre the next run starts from: its point, its normal (along the run) and the turn. let mut entry: Option<(Vec3, Vec3, f64)> = match closing { Some(_) if !translate => { - let (m, turn) = mitre(last_t, first_t)?; + let (m, turn) = mitre_of(last_t, first_t)?; Some((start, m, turn)) } _ => None, @@ -733,7 +726,7 @@ mod imp { None => closing, }; // The plane halving the corner at the run's end, and the turn there. - let exit = next.map(|t2| mitre(t1, t2)).transpose()?; + let exit = next.map(|t2| mitre_of(t1, t2)).transpose()?; // Each piece's sweep says where it left the profile: half-way along it each wall lies // over its piece, and at its end (less any straight lead-out past the corner) the // profile is where the next run takes it on. @@ -882,6 +875,10 @@ mod imp { /// exactly the profile's image, and SMLib skins the walls through them. Round a closed path the /// last section has to land on the first, and the ends are joined. pub(crate) fn sweep_controlled(plane: &Plane, region: &NumberedRegion, path: &[crate::PathSeg], ctl: &crate::SweepControl) -> Result { + let runs = smooth_runs(path)?; + if runs.len() > 1 { + return cornered_controlled(plane, region, path, &runs, ctl); + } let pieces = pieces(region.loops()); let c = curves(plane, &pieces)?; let start = path.first().map(crate::PathSeg::start).ok_or_else(|| KernelError::Invalid("the path needs 1…1000 segments".into()))?; @@ -927,6 +924,186 @@ mod imp { with_history(body, &roles, &pieces) } + /// `x` moved by `a`. + fn affine_apply(a: &Affine, x: Vec3) -> Vec3 { + let [c0, c1, c2] = a.m; + let v = |q: [f64; 3]| Vec3::new(q[0], q[1], q[2]); + v(c0) * x.x + v(c1) * x.y + v(c2) * x.z + v(a.t) + } + + /// `v` turned by `a`'s linear part. + fn affine_turn(a: &Affine, v: Vec3) -> Vec3 { + affine_apply(a, v) - affine_apply(a, Vec3::ZERO) + } + + /// `a` after `b`: x goes to a(b(x)). + fn affine_after(a: &Affine, b: &Affine) -> Affine { + let col = |c: [f64; 3]| p(affine_turn(a, Vec3::new(c[0], c[1], c[2]))); + Affine { m: [col(b.m[0]), col(b.m[1]), col(b.m[2])], t: p(affine_apply(a, Vec3::new(b.t[0], b.t[1], b.t[2]))) } + } + + /// The rigid turn by `angle` about the unit `k` through `center`, as an affine map. + fn affine_turned(center: Vec3, k: Vec3, angle: f64) -> Affine { + let col = |e: Vec3| p(turned(e, k, angle)); + Affine { m: [col(Vec3::X), col(Vec3::Y), col(Vec3::Z)], t: p(center - turned(center, k, angle)) } + } + + fn affine_moved(a: &Affine, by: Vec3) -> Affine { + Affine { m: a.m, t: p(Vec3::new(a.t[0], a.t[1], a.t[2]) + by) } + } + + const IDENTITY: Affine = Affine { m: [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]], t: [0.0; 3] }; + + /// A sweep that twists or scales along a path with corners, by the corner model of the plain + /// sweep ([`cornered`]): each smooth run of the path is swept through stations by the same + /// laws as a smooth path (the twist and the scale running with the length along the whole + /// path, each run going on from the section the last one ended with), and the runs meet at + /// each corner in a mitre. Turning with the path, each run is carried on straight past its + /// corners as a prism of its section there (the laws hold still across a mitre: the two runs' + /// sections meet on the plane halving the corner only when both are the corner's section) and + /// cut back to that plane; only moving along the path, the runs meet at the corner's section. + /// + /// Defined only where the laws keep their meaning at a sharp corner: an orientation direction + /// turns the profile there by a turn of its own, not the corner's, so its sections don't meet + /// in a mitre; guide rails place each section by where they cross its plane, which jumps at the + /// corner; and round a closed path the last section has to land on the first, which a twist or + /// scale breaks. Those are refused. + fn cornered_controlled( + plane: &Plane, + region: &NumberedRegion, + path: &[crate::PathSeg], + runs: &[std::ops::Range], + ctl: &crate::SweepControl, + ) -> Result { + let translate = match ctl.orientation { + _ if !ctl.rails.is_empty() => { + return Err(refuse("sweep along guide rails round a sharp corner of the path (the rails' sections jump there)")); + } + crate::SweepOrientation::Direction(_) => { + return Err(refuse( + "sweep kept at an orientation direction round a sharp corner of the path (its sections turn by their own turn there, not the corner's, and don't meet)", + )); + } + crate::SweepOrientation::Perpendicular => false, + crate::SweepOrientation::Parallel => true, + }; + let pieces = pieces(region.loops()); + let c = curves(plane, &pieces)?; + let bad = || KernelError::Invalid("a path segment has no direction".into()); + let start = path.first().map(crate::PathSeg::start).ok_or_else(|| KernelError::Invalid("empty path".into()))?; + let end = path.last().map(crate::PathSeg::end).ok_or_else(|| KernelError::Invalid("empty path".into()))?; + let lens: Vec = path.iter().map(seg_len).collect(); + let total: f64 = lens.iter().sum(); + if !(total > 1e-9 && total.is_finite()) { + return Err(KernelError::Invalid("the sweep path has no length".into())); + } + if end.dist(start) <= 1e-6 { + return Err(refuse( + "sweep with a twist or an end scale round a closed path with corners (its last section would have to land on its first)", + )); + } + let reach = pieces + .iter() + .flat_map(|x| (0..=8).map(move |i| x.seg.point_at(f64::from(i) / 8.0))) + .map(|q| plane.to_world(q).dist(start) * ctl.scale.max(1.0)) + .fold(0.0f64, f64::max); + let size = 4.0 * (total + reach) + 1.0; + let law = |u: f64| 1.0 + (ctl.scale - 1.0) * u; + let n0 = plane.normal().normalized().ok_or_else(|| KernelError::Invalid("profile plane".into()))?; + // The map carrying the profile as drawn onto the section where the next run starts, the + // mitre that run starts from (its point, its normal along the run, its turn) and how far + // along the path it starts. + let mut at_start = IDENTITY; + let mut entry: Option<(Vec3, Vec3, f64)> = None; + let mut before = 0.0f64; + let mut body: Option = None; + let mut inside = Vec::new(); + let mut last_map = IDENTITY; + for (ri, run) in runs.iter().enumerate() { + let segs = path.get(run.clone()).ok_or_else(|| KernelError::Invalid("path run".into()))?; + let length: f64 = lens.get(run.clone()).ok_or_else(|| KernelError::Invalid("path run".into()))?.iter().sum(); + let (u0, u1) = (before / total, (before + length) / total); + let (Some(first), Some(last)) = (segs.first(), segs.last()) else { return Err(KernelError::Invalid("path run".into())) }; + let ((t0, _), (_, t1)) = (first.tangents().ok_or_else(bad)?, last.tangents().ok_or_else(bad)?); + let (a0, b1) = (first.start(), last.end()); + // The run's own laws on its section at the start: the twist over its length, the scale + // from where the last run left it to where this one ends. + let run_ctl = crate::SweepControl { + orientation: ctl.orientation, + twist: ctl.twist * (u1 - u0), + scale: law(u1) / law(u0), + rails: Vec::new(), + rail_fit: ctl.rail_fit, + }; + let turn: f64 = segs.iter().map(path_turn).sum::() + run_ctl.twist.abs(); + let n = ((turn / (std::f64::consts::PI / 180.0)).ceil() as usize).clamp(MIN_STATIONS, MAX_STATIONS); + let (pts, tangents) = path_samples(segs, n)?; + let normal = affine_turn(&at_start, n0).normalized().ok_or_else(|| KernelError::Invalid("the sweep's section is degenerate".into()))?; + let pose = Plane::from_normal(a0, normal).ok_or_else(|| KernelError::Invalid("the sweep's section is degenerate".into()))?; + let st = crate::sweep_path::controlled_stations(&pose, &pts, &tangents, &[], &run_ctl)?; + let maps: Vec = st + .iter() + .map(|s| { + let [a, b, cc] = s.m; + affine_after(&Affine { m: [p(a), p(b), p(cc)], t: p(s.at - s.apply(a0)) }, &at_start) + }) + .collect(); + let (Some(&first_map), Some(&end_map)) = (maps.first(), maps.last()) else { return Err(KernelError::Invalid("sweep path".into())) }; + let mid = maps.get(maps.len() / 2).copied().unwrap_or(end_map); + inside.extend(seeds(plane, &pieces, |q| affine_apply(&mid, q))); + let mut piece = Brep::sweep_stations(&c, &maps, Ends::Capped).map_err(|e| failed("sweep", e))?; + let next = runs.get(ri + 1).and_then(|r| path.get(r.start)).map(|s| s.tangents().ok_or_else(bad).map(|t| t.0)).transpose()?; + let exit = next.map(|t2| mitre_of(t1, t2)).transpose()?; + if !translate { + // On past each mitre, the run's section there held still. + let over = |turn: f64| reach * (turn * 0.5).tan() * 1.1 + reach * 1e-3 + 1e-6; + let prism = |map: Affine, toward: Vec3, by: f64| -> Result { + Brep::sweep_stations(&c, &[map, affine_moved(&map, toward * by)], Ends::Capped).map_err(|e| failed("sweep corner", e)) + }; + if let Some((at, m, turn)) = entry { + let lead = prism(affine_moved(&first_map, t0 * -over(turn)), t0, over(turn))?; + piece = combined(&piece, &lead, solidcraft_smlib::BooleanOp::Union, "sweep corner")?; + piece = combined(&piece, &half_space(at, -m, size)?, solidcraft_smlib::BooleanOp::Subtract, "sweep mitre")?; + } + if let Some((m, turn)) = exit { + let tail = prism(end_map, t1, over(turn))?; + piece = combined(&piece, &tail, solidcraft_smlib::BooleanOp::Union, "sweep corner")?; + piece = combined(&piece, &half_space(b1, m, size)?, solidcraft_smlib::BooleanOp::Subtract, "sweep mitre")?; + } + } + body = Some(match body { + None => piece, + Some(b) => combined(&b, &piece, solidcraft_smlib::BooleanOp::Union, "sweep corner")?, + }); + // The section at the run's end, turned through the corner onto the next run. + last_map = end_map; + at_start = end_map; + entry = None; + if let (Some(t2), Some((m, turn)), false) = (next, exit, translate) { + let k = t1.cross(t2).normalized().ok_or_else(|| KernelError::Invalid("path corner".into()))?; + at_start = affine_after(&affine_turned(b1, k, turn), &end_map); + entry = Some((b1, m, turn)); + } + before += length; + } + let brep = body.ok_or_else(|| KernelError::Invalid("empty path".into()))?; + let body = body_of(&brep, "sweep")?; + let end_plane = Plane::new(affine_apply(&last_map, plane.origin), affine_turn(&last_map, plane.x), affine_turn(&last_map, plane.y)) + .ok_or_else(|| KernelError::Invalid("the sweep's end section is degenerate".into()))?; + let roles = roles(&body, plane, Some(&end_plane), &seeds(plane, &pieces, |q| q), &inside, false)?; + with_history(body, &roles, &pieces) + } + + /// The plane halving the corner from direction `t1` to `t2` (its unit normal) and the turn + /// there; a path that turns back on itself has none. + fn mitre_of(t1: Vec3, t2: Vec3) -> Result<(Vec3, f64)> { + let turn = t1.dot(t2).clamp(-1.0, 1.0).acos(); + if turn > std::f64::consts::PI - 1e-3 { + return Err(KernelError::Invalid("the path turns back on itself at a corner".into())); + } + Ok(((t1 + t2).normalized().ok_or_else(|| KernelError::Invalid("path corner".into()))?, turn)) + } + /// A loft through `sections` (each a closed loop of pieces, all re-split to the same count /// and lined up), `first` the index of the section given first (its cap is the start cap). pub(crate) fn loft(sections: &[(Plane, Vec)], first: usize) -> Result {