Fix shelling revolved barrels (#2421) (#2486)

* claim: #2421

* claim: #2421

* Fix shelling circular-meridian barrels (#2421)
This commit is contained in:
fkirill authored and GitHub committed 2026-10-19 16:09:11 -04:00
1 parent c1f9224579
commit 42e991069f
5 files changed
+185 -8

No files matched your search

+3 -2
View File
@@ -459,10 +459,11 @@ completed drawings publish atomically. The browser still exports synchronously.
and author occurrence paths retain the chosen placements; missing/split faces refuse rather
than retarget. General free-form profiles, seams, stepped cylinders and other curved surfaces
remain unsupported. STEP round-trip and independent radial/volume checks cover this subset.
- Shell and offset faces work on bodies of planes, cylinders, cones and spheres (convex or not:
- Shell and offset faces work on bodies of planes, cylinders, cones, spheres and tori (convex or not:
filleted boxes, bosses, domes, countersinks; corners where four or more planes meet, such as a
floor falling to a drain, as long as the corner's edges are all convex or all concave); draft on convex planar bodies and on walls (planes, cylinders → cones) between caps; lofts through three or more sections are smooth (B-spline sides through every section), two
sections ruled.
sections ruled. Circular-meridian barrels retain curved inner walls through either axial
opening (#2421).
- Sketch corner tools: fillet and all three chamfer modes pick a connected corner even when
its endpoint overlaps the fixed origin or a loose point. Ordinary drawing still snaps to
+7 -5
View File
@@ -28,8 +28,9 @@ pub(crate) enum Surf {
/// outward normal points away from the axis.
Cone { v: Vec3, a: Vec3, half: f64, convex: bool },
/// Axis point and unit axis, the tube's centre circle (radius `big` at height `h` along the
/// axis) and the tube radius; `convex` when the outward normal points away from the tube's
/// centre.
/// axis) and the tube radius; `big` is negative on the inner sheet of a spindle torus,
/// whose meridian circle's centre lies across the axis. `convex` when the outward normal
/// points away from the tube's centre.
Torus { o: Vec3, a: Vec3, big: f64, h: f64, r: f64, convex: bool },
}
@@ -292,9 +293,10 @@ fn torus_of(f: &mt::Face, s: &[(Vec3, Vec3)], tol: f64) -> Option<Surf> {
}
let x = crate::polyhedron::solve3_pub(m, rhs)?;
let (big, h, r) = (x[0], x[1], x[2]);
// (A tube wider than its circle, a spindle torus, is fine: blends use its outer part, where
// each point's tube centre is the one on its own side of the axis.)
if !(big > 1e-9 && r.abs() > 1e-9) {
// A spindle torus also has an inner sheet: a barrel revolved from an arc whose
// centre is across the axis. Its signed ring radius is negative; retain that sign
// so distances, normals and the moved meridian use the centre on the opposite side.
if !(big.abs() > 1e-9 && r.abs() > 1e-9) {
return None;
}
let t = Surf::Torus { o, a, big, h, r: r.abs(), convex: r > 0.0 };
+81 -1
View File
@@ -9,7 +9,7 @@ use solidcraft_geom::{Plane, Vec3};
use truck_modeling::{self as mt, builder};
use crate::body::{Body, Solid, from_p3, p3, v3};
use crate::history::{EdgeOrigin, FaceOrigin, FaceProv, History};
use crate::history::{Change, EdgeOrigin, FaceOrigin, FaceProv, History};
use crate::record;
use crate::{KernelError, Result, guard};
@@ -490,6 +490,9 @@ fn shell_planar(b: &Body, open: &[Vec3], thickness: f64) -> Result<Body> {
"the rim would have no thickness: an open face meets a round of radius {r:.4} mm tangentially, and the shell is {thickness:.4} mm thick (make the round smaller than the thickness)"
)));
}
if let Some(shell) = shell_barrel(&healed, &opened, thickness)? {
return Ok(record::after(shell, &healed, &record::counts(&[b])));
}
let margin = thickness + size * 0.05;
shell_opened(b, &healed, open, &opened, thickness, margin).map_err(|e| match rim_without_thickness(&healed, &opened, thickness, false) {
Some(r) => unsupported_shell(&format!(
@@ -499,6 +502,83 @@ fn shell_planar(b: &Body, open: &[Vec3], thickness: f64) -> Result<Body> {
})
}
/// A convex circular-meridian barrel between two axial caps. Sew its exact inset walls
/// to the original walls at annular rims: a Boolean of the two spindle sheets cannot
/// reliably find their cap intersections, and sweeping an inset cap makes a cylindrical
/// lip that cuts away part of the curved wall.
fn shell_barrel(b: &Body, opened: &[usize], thickness: f64) -> Result<Option<Body>> {
use crate::offset::Surf;
if b.solid.boundaries().len() != 1 || b.face_count() > 256 {
return Ok(None);
}
let faces: Vec<mt::Face> = b.solid.face_iter().cloned().collect();
let tol = (b.size() * 1e-7).max(1e-9) * 100.0;
let surfs: Option<Vec<Surf>> = faces.iter().map(|f| crate::offset::surf_of(f, tol)).collect();
let Some(surfs) = surfs else { return Ok(None) };
let Some((centre, axis, big, radius)) = surfs.iter().find_map(|s| match *s {
Surf::Torus { o, a, big, h, r, convex: true } if big < -tol => Some((o + a * h, a, big, r)),
_ => None,
}) else {
return Ok(None);
};
let mut caps = Vec::new();
for (i, s) in surfs.iter().enumerate() {
match *s {
Surf::Torus { o, a, big: ring, h, r, convex: true }
if (o + a * h).dist(centre) < tol && a.dot(axis).abs() > 1.0 - 1e-9 && (ring - big).abs() < tol && (r - radius).abs() < tol => {}
Surf::Plane { n, d } if n.dot(axis).abs() > 1.0 - 1e-9 && faces.get(i).is_some_and(|f| f.boundaries().len() == 1) => {
caps.push((i, (d - n.dot(centre)) / n.dot(axis), n.dot(axis)));
}
_ => return Ok(None),
}
}
if caps.len() != 2 || opened.iter().any(|i| !caps.iter().any(|c| c.0 == *i)) {
return Ok(None);
}
caps.sort_by(|a, b| a.1.total_cmp(&b.1));
let (Some(&(lower, lo, down)), Some(&(upper, hi, up))) = (caps.first(), caps.get(1)) else { return Ok(None) };
if down >= 0.0 || up <= 0.0 {
return Ok(None);
}
let lo = lo + if opened.contains(&lower) { 0.0 } else { thickness };
let hi = hi - if opened.contains(&upper) { 0.0 } else { thickness };
let inner_radius = radius - thickness;
if lo >= hi || inner_radius <= 0.0 || [lo, hi].iter().any(|z| inner_radius * inner_radius - z * z <= big * big) {
return Err(KernelError::Invalid("shell thickness leaves no barrel cavity".into()));
}
let cavity = offset_planar(b, |i, _| if opened.contains(&i) { 0.0 } else { -thickness })?;
let history = cavity.history().ok_or_else(|| unsupported_shell("the barrel cavity has no face history"))?;
// Every wall must still be the one offset of its source, in source order. No collapsed
// faces or changed topology can be sewn by this construction.
if cavity.face_count() != faces.len()
|| history.faces.iter().enumerate().any(|(i, f)| f.origins.as_slice() != [FaceOrigin::Face { operand: 0, face: i }])
{
return Err(unsupported_shell("the barrel cavity changed topology"));
}
let inner: Vec<mt::Face> = cavity.solid.face_iter().cloned().collect();
let mut out = Vec::new();
let mut provenance = Vec::new();
for (i, outer) in faces.iter().enumerate() {
let inset = inner.get(i).ok_or_else(|| unsupported_shell("the barrel cavity lost a face"))?;
if opened.contains(&i) {
let mut wires = outer.absolute_boundaries().to_vec();
wires.extend(inset.absolute_boundaries().iter().map(|w| w.inverse()));
let mut rim = mt::Face::try_new(wires, outer.surface()).map_err(|e| KernelError::Failed(format!("shell rim: {e}")))?;
if !outer.orientation() {
rim.invert();
}
out.push(rim);
provenance.push(record::from_face(0, i, Change::Modified));
} else {
out.extend([outer.clone(), inset.inverse()]);
provenance.extend([record::from_face(0, i, Change::Kept), record::generated(vec![FaceOrigin::Offset { operand: 0, face: i }])]);
}
}
let solid = Solid::try_new(vec![out.into()]).map_err(|e| KernelError::Failed(format!("shell barrel: {e}")))?;
let copies = record::edges_by_identity(&cavity, history).filter_map(|(id, origins)| origins.into_iter().next().map(|o| (id, o))).collect();
record::attach(Body::new(solid)?, &[record::Operand::new(b)], Some(provenance), copies).map(Some)
}
/// The radius of a convex round (cylinder or torus) that meets an open face tangentially and
/// is at least `thickness`: the cavity's wall then passes through the rim where the round meets
/// the open face, leaving nothing between them.
+2
View File
@@ -33,6 +33,8 @@ pub enum FaceSurface {
radius: f64,
},
/// Centre of the ring, its axis, the ring (major) and tube (minor) radii.
/// `major` is signed: negative on a spindle torus's inner sheet, whose tube centre
/// lies across the axis from the face (a revolved barrel).
Torus {
center: Vec3,
axis: UnitVec3,
+92
View File
@@ -0,0 +1,92 @@
//! #2421: shelling a circular-meridian barrel must retain its curved wall through the rim.
use std::f64::consts::PI;
use solidcraft_geom::{Loop2, Plane, Region2, Seg2, Vec2, Vec3};
use solidcraft_kernel::history::FaceOrigin;
use solidcraft_kernel::*;
const RADIUS: f64 = 24.0;
const CENTRE: f64 = -10.0;
const HALF_HEIGHT: f64 = 13.4;
fn barrel() -> Body {
let angle = (HALF_HEIGHT / RADIUS).asin();
let end_radius = CENTRE + RADIUS * angle.cos();
let region = Region2 {
outer: Loop2 {
segs: vec![
Seg2::Line { a: Vec2::ZERO, b: Vec2::new(end_radius, 0.0) },
Seg2::Arc { center: Vec2::new(CENTRE, HALF_HEIGHT), radius: RADIUS, start: -angle, sweep: 2.0 * angle },
Seg2::Line { a: Vec2::new(end_radius, 2.0 * HALF_HEIGHT), b: Vec2::new(0.0, 2.0 * HALF_HEIGHT) },
Seg2::Line { a: Vec2::new(0.0, 2.0 * HALF_HEIGHT), b: Vec2::ZERO },
],
},
holes: vec![],
};
let plane = Plane::new(Vec3::ZERO, Vec3::X, Vec3::Z).unwrap();
revolve(&plane, &[region], Vec2::ZERO, Vec2::Y, 2.0 * PI).unwrap().pop().unwrap()
}
// Integral of pi * (CENTRE + sqrt(r^2 - (z-HALF_HEIGHT)^2))^2.
fn integral(r: f64, z: f64) -> f64 {
let u = z - HALF_HEIGHT;
PI * ((CENTRE * CENTRE + r * r) * u - u.powi(3) / 3.0 + CENTRE * (u * (r * r - u * u).sqrt() + r * r * (u / r).asin()))
}
fn check_volume(body: &Body, lo: f64, hi: f64) {
let want = integral(RADIUS, 2.0 * HALF_HEIGHT) - integral(RADIUS, 0.0) - (integral(RADIUS - 2.0, hi) - integral(RADIUS - 2.0, lo));
let volume = measure(body).unwrap().volume;
assert!((volume - want).abs() < want * 1e-3, "{volume} vs {want}");
}
#[test]
fn shell_of_a_revolved_barrel() {
let barrel = barrel();
let side = (0..barrel.face_count())
.find_map(|i| match face_surface(&barrel, i) {
Some(s @ FaceSurface::Torus { major, minor, .. }) if (major - CENTRE).abs() < 1e-6 && (minor - RADIUS).abs() < 1e-6 => Some(s),
_ => None,
})
.expect("barrel side is the inner sheet of a spindle torus");
assert!(side.nearest(Vec3::new(15.0, 0.0, HALF_HEIGHT)).unwrap().dist(Vec3::new(14.0, 0.0, HALF_HEIGHT)) < 1e-6);
let result = shell(&barrel, &[Vec3::new(0.0, 0.0, 2.0 * HALF_HEIGHT)], 2.0).unwrap();
assert!(result.validity().is_empty(), "{:?}", result.validity());
assert_eq!(result.shell_count(), 1);
let mesh = result.tessellate(0.005).unwrap();
assert!(mesh.contains(Vec3::new(0.0, 0.0, 1.0)), "closed floor");
assert!(!mesh.contains(Vec3::new(0.0, 0.0, 3.0)), "open cavity");
assert!(mesh.contains(Vec3::new(13.0, 0.0, HALF_HEIGHT)), "barrel wall");
assert!(!mesh.contains(Vec3::new(11.0, 0.0, HALF_HEIGHT)), "inside wall");
assert!(mesh.contains(Vec3::new(8.0, 0.0, 26.7)), "curved wall reaches the rim without a cylindrical lip cutting it away");
check_volume(&result, 2.0, 2.0 * HALF_HEIGHT);
let history = result.history().expect("exact shell face history");
assert_eq!(history.operands, 1);
assert_eq!(history.faces.iter().filter(|f| matches!(f.origins.as_slice(), [FaceOrigin::Offset { operand: 0, .. }])).count(), 4);
let step = step_export(&[&result], "barrel shell").unwrap();
let imported = step_import(&step).unwrap();
assert_eq!(imported.bodies.len(), 1);
let round_trip = &imported.bodies.first().unwrap().body;
assert!(round_trip.validity().is_empty());
check_volume(round_trip, 2.0, 2.0 * HALF_HEIGHT);
}
#[test]
fn barrel_shell_opens_either_or_both_caps_and_refuses_a_vanished_cavity() {
let barrel = barrel();
for both in [false, true] {
let mut opened = vec![Vec3::ZERO];
if both {
opened.push(Vec3::new(0.0, 0.0, 2.0 * HALF_HEIGHT));
}
let result = shell(&barrel, &opened, 2.0).unwrap();
assert!(result.validity().is_empty());
let mesh = result.tessellate(0.005).unwrap();
assert!(!mesh.contains(Vec3::new(0.0, 0.0, 1.0)));
assert_eq!(mesh.contains(Vec3::new(0.0, 0.0, 25.8)), !both);
check_volume(&result, 0.0, 2.0 * HALF_HEIGHT - if both { 0.0 } else { 2.0 });
}
for thickness in [11.0, 24.0] {
assert!(shell(&barrel, &[Vec3::ZERO], thickness).is_err());
}
}