Ruled B-spline sheets that are circular cylinders or cones are written as CYLINDRICAL_SURFACE and CONICAL_SURFACE, so other readers no longer bound the part by sheets that reach past its faces.
This commit is contained in:
1 parent
2c754c430b
commit
2e6951135a
2 files changed
+191
-64
No files matched your search
@@ -863,6 +863,66 @@ fn glued_halves_export_as_whole_faces() {
|
|||||||
assert_eq!(imp.bodies[0].file_faces, 8);
|
assert_eq!(imp.bodies[0].file_faces, 8);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// A slot plate with a round on its top outline (issue #612): the extruded arc ends and the
|
||||||
|
/// rounds along the straight edges are lone B-spline sheets, written as cylinders bounded by
|
||||||
|
/// their faces. The rounds' sheets reach far past their edges, and a reader bounding the part by
|
||||||
|
/// its surfaces saw a 60 mm part as 130 mm long.
|
||||||
|
#[test]
|
||||||
|
fn rounded_slot_exports_cylinders() {
|
||||||
|
use solidcraft_geom::Seg2;
|
||||||
|
use std::f64::consts::{FRAC_PI_2, PI};
|
||||||
|
let outer = Loop2 {
|
||||||
|
segs: vec![
|
||||||
|
Seg2::Line { a: Vec2::new(10.0, -10.0), b: Vec2::new(50.0, -10.0) },
|
||||||
|
Seg2::Arc { center: Vec2::new(50.0, 0.0), radius: 10.0, start: -FRAC_PI_2, sweep: PI },
|
||||||
|
Seg2::Line { a: Vec2::new(50.0, 10.0), b: Vec2::new(10.0, 10.0) },
|
||||||
|
Seg2::Arc { center: Vec2::new(10.0, 0.0), radius: 10.0, start: FRAC_PI_2, sweep: PI },
|
||||||
|
],
|
||||||
|
};
|
||||||
|
let plate = extrude(&Plane::XY, &[Region2 { outer, holes: vec![] }], 0.0, 4.0).unwrap().pop().unwrap();
|
||||||
|
let edges = [Vec3::new(30.0, -10.0, 4.0), Vec3::new(30.0, 10.0, 4.0), Vec3::new(0.0, 0.0, 4.0), Vec3::new(60.0, 0.0, 4.0)];
|
||||||
|
let b = fillet(&plate, &edges, 1.0).unwrap();
|
||||||
|
let text = step_export(&[&b], "t").unwrap();
|
||||||
|
assert!(!text.contains("B_SPLINE_SURFACE"), "{text}");
|
||||||
|
assert_eq!(text.matches("CYLINDRICAL_SURFACE(").count(), 4);
|
||||||
|
assert_eq!(text.matches("TOROIDAL_SURFACE(").count(), 2);
|
||||||
|
// No point of the file (surface placements included) lies outside the part.
|
||||||
|
let imp = round_trip(&b);
|
||||||
|
for line in text.lines().filter(|l| l.contains("CARTESIAN_POINT")) {
|
||||||
|
let Some(xyz) = line.split("((").nth(1).and_then(|r| r.split("))").next()) else { continue };
|
||||||
|
let x: f64 = xyz.split(',').next().unwrap().trim().parse().unwrap();
|
||||||
|
assert!((-1e-6..=60.0 + 1e-6).contains(&x), "{line}");
|
||||||
|
}
|
||||||
|
// The volume analytically: the plate less the round's corner section swept along the edges
|
||||||
|
// (Pappus: the section's centroid runs 0.2234 r inside the edge round the arcs).
|
||||||
|
let section = 1.0 - PI / 4.0;
|
||||||
|
let centroid = (10.0 - 3.0 * PI) / (3.0 * (4.0 - PI));
|
||||||
|
let want = (800.0 + PI * 100.0) * 4.0 - section * (80.0 + std::f64::consts::TAU * (10.0 - centroid));
|
||||||
|
assert!(rel(measure(&imp.bodies[0].body).unwrap().volume, want) < 1e-3);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A countersink cut into a plate (issue #612): the cone is a tapered extrusion of a disc, a
|
||||||
|
/// B-spline sheet per half, written as one CONICAL_SURFACE face (the sheets reached below the
|
||||||
|
/// plate).
|
||||||
|
#[test]
|
||||||
|
fn countersink_exports_one_cone() {
|
||||||
|
use std::f64::consts::FRAC_PI_4;
|
||||||
|
let plate = box_solid(Vec3::new(-10.0, -10.0, 0.0), Vec3::new(10.0, 10.0, 4.0)).unwrap();
|
||||||
|
// A 90° countersink, radius 4 at the top face, down from 1 mm above it to radius 1.8, and the
|
||||||
|
// 2 mm drill through.
|
||||||
|
let disc = Region2 { outer: Loop2::circle(Vec2::ZERO, 5.0), holes: vec![] };
|
||||||
|
let cone = crate::extrude_tapered(&Plane::XY.offset(5.0), &disc, 3.2, -1.0, -FRAC_PI_4).unwrap();
|
||||||
|
let drill = cylinder(Vec3::new(0.0, 0.0, -1.0), Vec3::Z, 2.0, 6.0).unwrap();
|
||||||
|
let b = boolean(&boolean(&plate, &cone, BoolOp::Cut).unwrap().unwrap(), &drill, BoolOp::Cut).unwrap().unwrap();
|
||||||
|
let text = step_export(&[&b], "t").unwrap();
|
||||||
|
assert!(!text.contains("B_SPLINE_SURFACE"), "{text}");
|
||||||
|
assert_eq!(text.matches("CONICAL_SURFACE(").count(), 1, "{text}");
|
||||||
|
assert_eq!(text.matches("CYLINDRICAL_SURFACE(").count(), 1, "{text}");
|
||||||
|
let imp = round_trip(&b);
|
||||||
|
// Six box faces, the countersink and the drill.
|
||||||
|
assert_eq!(imp.bodies[0].file_faces, 8);
|
||||||
|
}
|
||||||
|
|
||||||
/// Knot multiplicities are expanded into one value each before the knot count is compared with
|
/// Knot multiplicities are expanded into one value each before the knot count is compared with
|
||||||
/// the control points, so the sum has to be checked first: 1,000,000 knots of multiplicity 64
|
/// the control points, so the sum has to be checked first: 1,000,000 knots of multiplicity 64
|
||||||
/// against two control points asked for a 500 MB vector (20,000,000 for 10 GB) only to reject
|
/// against two control points asked for a 500 MB vector (20,000,000 for 10 GB) only to reject
|
||||||
|
|||||||
+131
-64
@@ -151,8 +151,8 @@ struct Out {
|
|||||||
shared: HashMap<String, u64>,
|
shared: HashMap<String, u64>,
|
||||||
/// Surfaces written with the opposite normal to the one they replace.
|
/// Surfaces written with the opposite normal to the one they replace.
|
||||||
flipped: std::collections::HashSet<u64>,
|
flipped: std::collections::HashSet<u64>,
|
||||||
/// B-spline cylinder sheets of the body being copied under merged faces, with the direction
|
/// B-spline cylinder and cone sheets of the body being copied to write as analytic surfaces,
|
||||||
/// of the cylinder's parameter seam.
|
/// with the direction of their parameter seam.
|
||||||
merged: HashMap<u64, V3>,
|
merged: HashMap<u64, V3>,
|
||||||
/// Faces of the body being copied: exchange id → written id.
|
/// Faces of the body being copied: exchange id → written id.
|
||||||
faces_out: HashMap<u64, u64>,
|
faces_out: HashMap<u64, u64>,
|
||||||
@@ -270,13 +270,13 @@ impl Out {
|
|||||||
map.insert(id, new);
|
map.insert(id, new);
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
// Flat B-spline sheets are planes; cylindrical ones become cylinders when their
|
// Flat B-spline sheets are planes; ruled ones become cylinders and cones when
|
||||||
// pieces were merged into one face (a lone piece stays as written).
|
// `analytic_sheets` chose them (their pieces merged, or a lone piece's edges allow).
|
||||||
if !done
|
if !done
|
||||||
&& let Some(a) = planar_bspline(ex, e).map(|kind| Analytic { kind, flip: false }).or_else(|| {
|
&& let Some(a) = planar_bspline(ex, e).map(|kind| Analytic { kind, flip: false }).or_else(|| {
|
||||||
let seam = self.merged.get(&id)?;
|
let seam = self.merged.get(&id)?;
|
||||||
let mut a = cylindrical_bspline(ex, e)?;
|
let mut a = ruled_bspline(ex, e)?;
|
||||||
if let AnalyticKind::Cylinder { x, .. } = &mut a.kind {
|
if let AnalyticKind::Cylinder { x, .. } | AnalyticKind::Cone { x, .. } = &mut a.kind {
|
||||||
*x = *seam;
|
*x = *seam;
|
||||||
}
|
}
|
||||||
Some(a)
|
Some(a)
|
||||||
@@ -609,10 +609,11 @@ fn planar_bspline(ex: &p21::Exchange, e: &p21::Entity) -> Option<AnalyticKind> {
|
|||||||
Some(AnalyticKind::Plane { o, z, x })
|
Some(AnalyticKind::Plane { o, z, x })
|
||||||
}
|
}
|
||||||
|
|
||||||
/// A B-spline surface that is a circular cylinder (a circle or arc swept along a line, as truck
|
/// A B-spline surface that is a circular cylinder or cone: straight rulings between two coaxial
|
||||||
/// makes for extruded round profiles), with its normal direction relative to the cylinder's
|
/// circles or arcs (or an arc and the cone's apex), as truck makes for extruded round profiles,
|
||||||
/// outward normal.
|
/// rounds along straight edges and countersinks. With its normal direction relative to the
|
||||||
fn cylindrical_bspline(ex: &p21::Exchange, e: &p21::Entity) -> Option<Analytic> {
|
/// surface's outward normal.
|
||||||
|
fn ruled_bspline(ex: &p21::Exchange, e: &p21::Entity) -> Option<Analytic> {
|
||||||
use truck_modeling::{ParametricSurface, ParametricSurface3D};
|
use truck_modeling::{ParametricSurface, ParametricSurface3D};
|
||||||
if !(e.has("B_SPLINE_SURFACE") || e.name() == "B_SPLINE_SURFACE_WITH_KNOTS") {
|
if !(e.has("B_SPLINE_SURFACE") || e.name() == "B_SPLINE_SURFACE_WITH_KNOTS") {
|
||||||
return None;
|
return None;
|
||||||
@@ -624,45 +625,98 @@ fn cylindrical_bspline(ex: &p21::Exchange, e: &p21::Entity) -> Option<Analytic>
|
|||||||
let p = s.subs(u, v);
|
let p = s.subs(u, v);
|
||||||
[p.x, p.y, p.z]
|
[p.x, p.y, p.z]
|
||||||
};
|
};
|
||||||
// Which parameter sweeps along a line: the same translation from one end to the other at
|
// Which parameter runs along the rulings: straight from one end to the other at every point
|
||||||
// every point of the profile.
|
// of the profile.
|
||||||
for along_v in [true, false] {
|
for along_v in [true, false] {
|
||||||
let point = |t: f64, w: f64| if along_v { at(u0 + (u1 - u0) * t, v0 + (v1 - v0) * w) } else { at(u0 + (u1 - u0) * w, v0 + (v1 - v0) * t) };
|
let point = |t: f64, w: f64| if along_v { at(u0 + (u1 - u0) * t, v0 + (v1 - v0) * w) } else { at(u0 + (u1 - u0) * w, v0 + (v1 - v0) * t) };
|
||||||
let prof: Vec<V3> = (0..=8).map(|k| point(k as f64 / 8.0, 0.0)).collect();
|
let grid: Vec<Vec<V3>> = (0..=4).map(|m| (0..=8).map(|k| point(k as f64 / 8.0, m as f64 / 4.0)).collect()).collect();
|
||||||
let d = sub(point(0.0, 1.0), point(0.0, 0.0));
|
let (Some(p0), Some(p1)) = (grid.first(), grid.last()) else { continue };
|
||||||
let len = norm(d);
|
let Some(&first) = p0.first() else { continue };
|
||||||
let scale = prof.iter().map(|p| norm(sub(*p, prof[0]))).fold(len, f64::max);
|
let scale = grid.iter().flatten().map(|p| norm(sub(*p, first))).fold(0.0, f64::max);
|
||||||
let tol = 1e-7 * (1.0 + scale);
|
let tol = 1e-7 * (1.0 + scale);
|
||||||
if len < tol
|
let straight = (0..=8).all(|k| {
|
||||||
|| (0..=8).any(|k| {
|
let (Some(&a), Some(&b)) = (p0.get(k), p1.get(k)) else { return false };
|
||||||
let t = k as f64 / 8.0;
|
let Some(d) = unit(sub(b, a)) else { return false };
|
||||||
(0..=4).any(|m| norm(sub(sub(point(t, m as f64 / 4.0), point(t, 0.0)), mul(d, m as f64 / 4.0))) > tol)
|
grid.iter().all(|row| row.get(k).is_some_and(|q| norm(cross(sub(*q, a), d)) <= tol))
|
||||||
})
|
});
|
||||||
{
|
if !straight {
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
let (Some(&a), Some(&b), Some(&c)) = (prof.first(), prof.get(4), prof.get(8)) else { continue };
|
// Each end: a circle (centre, radius, axis) or a single point (a cone's apex).
|
||||||
let (centre, r, n) = circle3(a, b, c).or_else(|| circle3(a, prof[2], b))?;
|
let ring = |prof: &[V3]| -> Option<(V3, f64, Option<V3>)> {
|
||||||
let z = unit(d)?;
|
let &a = prof.first()?;
|
||||||
if norm(cross(n, z)) > 1e-7 || prof.iter().any(|p| (norm(sub(*p, centre)) - r).abs() > tol) {
|
if prof.iter().all(|p| norm(sub(*p, a)) <= tol) {
|
||||||
|
return Some((a, 0.0, None));
|
||||||
|
}
|
||||||
|
let (&b, &c, &h) = (prof.get(4)?, prof.get(8)?, prof.get(2)?);
|
||||||
|
let (centre, r, n) = circle3(a, b, c).or_else(|| circle3(a, h, b))?;
|
||||||
|
prof.iter().all(|p| (norm(sub(*p, centre)) - r).abs() <= tol).then_some((centre, r, Some(n)))
|
||||||
|
};
|
||||||
|
let ((c0, r0, n0), (c1, r1, n1)) = (ring(p0)?, ring(p1)?);
|
||||||
|
let axis = unit(sub(c1, c0))?;
|
||||||
|
if [n0, n1].iter().flatten().any(|n| norm(cross(*n, axis)) > 1e-7) || (n0.is_none() && n1.is_none()) {
|
||||||
|
return None;
|
||||||
|
}
|
||||||
|
let height = norm(sub(c1, c0));
|
||||||
|
// The radius grows along z (a cylinder keeps the sweep's direction).
|
||||||
|
let (o, z, r, angle) = if (r1 - r0).abs() <= tol {
|
||||||
|
(c0, axis, r0, 0.0)
|
||||||
|
} else if r1 > r0 {
|
||||||
|
(c1, axis, r1, ((r1 - r0) / height).atan())
|
||||||
|
} else {
|
||||||
|
(c0, mul(axis, -1.0), r0, ((r0 - r1) / height).atan())
|
||||||
|
};
|
||||||
|
let radius_at = |q: V3| r + dot(sub(q, o), z) * angle.tan();
|
||||||
|
let radial = |q: V3| {
|
||||||
|
let v = sub(q, o);
|
||||||
|
sub(v, mul(z, dot(v, z)))
|
||||||
|
};
|
||||||
|
if grid.iter().flatten().any(|q| (norm(radial(*q)) - radius_at(*q)).abs() > tol) {
|
||||||
return None;
|
return None;
|
||||||
}
|
}
|
||||||
// The surface's own normal against the outward one, mid-face.
|
// The surface's own normal against the outward one, mid-face.
|
||||||
let (um, vm) = ((u0 + u1) / 2.0, (v0 + v1) / 2.0);
|
let (um, vm) = ((u0 + u1) / 2.0, (v0 + v1) / 2.0);
|
||||||
let nn = s.normal(um, vm);
|
let nn = s.normal(um, vm);
|
||||||
let q = at(um, vm);
|
let q = at(um, vm);
|
||||||
let radial = sub(sub(q, centre), mul(z, dot(sub(q, centre), z)));
|
let eq = unit(radial(q))?;
|
||||||
let flip = dot([nn.x, nn.y, nn.z], radial) < 0.0;
|
let outward = sub(mul(eq, angle.cos()), mul(z, angle.sin()));
|
||||||
|
let flip = dot([nn.x, nn.y, nn.z], outward) < 0.0;
|
||||||
// The parameter seam opposite the middle of the sheet, away from its edges.
|
// The parameter seam opposite the middle of the sheet, away from its edges.
|
||||||
let x = unit(mul(radial, -1.0)).or_else(|| unit(sub(a, centre)))?;
|
let x = mul(eq, -1.0);
|
||||||
return Some(Analytic { kind: AnalyticKind::Cylinder { o: centre, z, x, r }, flip });
|
let kind = if angle == 0.0 { AnalyticKind::Cylinder { o, z, x, r } } else { AnalyticKind::Cone { o, z, x, r, angle } };
|
||||||
|
return Some(Analytic { kind, flip });
|
||||||
}
|
}
|
||||||
None
|
None
|
||||||
}
|
}
|
||||||
|
|
||||||
/// A B-spline surface that is really a plane or a cylinder.
|
/// A B-spline surface that is really a plane, a cylinder or a cone.
|
||||||
fn analytic_bspline(ex: &p21::Exchange, e: &p21::Entity) -> Option<Analytic> {
|
fn analytic_bspline(ex: &p21::Exchange, e: &p21::Entity) -> Option<Analytic> {
|
||||||
planar_bspline(ex, e).map(|kind| Analytic { kind, flip: false }).or_else(|| cylindrical_bspline(ex, e))
|
planar_bspline(ex, e).map(|kind| Analytic { kind, flip: false }).or_else(|| ruled_bspline(ex, e))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Every edge of a face on a cylinder or cone is a circle square to its axis or one of its
|
||||||
|
/// rulings (a line along the axis, or through a cone's apex). Faces bounded by other curves (a
|
||||||
|
/// hole crossing a tube wall) keep their B-spline sheet: readers lay those curves out far more
|
||||||
|
/// slowly on the analytic surface than on the sheet they came with.
|
||||||
|
fn square_or_ruled(ex: &p21::Exchange, fe: &p21::Entity, kind: &AnalyticKind) -> bool {
|
||||||
|
let (z, apex) = match *kind {
|
||||||
|
AnalyticKind::Cylinder { z, .. } => (z, None),
|
||||||
|
AnalyticKind::Cone { o, z, r, angle, .. } if angle.tan() > 1e-12 => (z, Some(sub(o, mul(z, r / angle.tan())))),
|
||||||
|
_ => return false,
|
||||||
|
};
|
||||||
|
face_edges(ex, fe).is_some_and(|ls| {
|
||||||
|
ls.iter().flatten().all(|(x, _)| {
|
||||||
|
edge_samples(ex, *x).is_some_and(|pts| {
|
||||||
|
let Some(&q0) = pts.first() else { return false };
|
||||||
|
let tol = 1e-7 * (1.0 + norm(q0));
|
||||||
|
let ruling = match apex {
|
||||||
|
None => pts.iter().all(|q| norm(cross(sub(*q, q0), z)) <= tol),
|
||||||
|
Some(a) => pts.iter().all(|q| norm(cross(sub(*q, a), sub(q0, a))) <= tol * (1.0 + norm(sub(q0, a)))),
|
||||||
|
};
|
||||||
|
ruling || pts.iter().all(|q| dot(sub(*q, q0), z).abs() <= tol)
|
||||||
|
})
|
||||||
|
})
|
||||||
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Points along an edge's curve (its ends for a line, None for a conic it cannot sample).
|
/// Points along an edge's curve (its ends for a line, None for a conic it cannot sample).
|
||||||
@@ -833,8 +887,9 @@ fn face_edges(ex: &p21::Exchange, face: &p21::Entity) -> Option<Vec<Vec<(u64, bo
|
|||||||
|
|
||||||
/// Faces that truck splits (a revolution in two or three turns) joined back into one face per
|
/// Faces that truck splits (a revolution in two or three turns) joined back into one face per
|
||||||
/// analytic surface, by dropping the edges between them. Faces whose union would lose all its
|
/// analytic surface, by dropping the edges between them. Faces whose union would lose all its
|
||||||
/// edges, or whose leftover edges do not close into loops, stay apart.
|
/// edges, or whose leftover edges do not close into loops, stay apart. Returns the surfaces of
|
||||||
fn merge_split_faces(ex: &mut p21::Exchange, paint: &mut HashMap<u64, FaceLook>, keep: &[Vec<Vec3>]) -> HashMap<u64, V3> {
|
/// merged faces.
|
||||||
|
fn merge_split_faces(ex: &mut p21::Exchange, paint: &mut HashMap<u64, FaceLook>, keep: &[Vec<Vec3>]) -> std::collections::HashSet<u64> {
|
||||||
// An edge on a line the user split along: every sample within a hair of the polyline.
|
// An edge on a line the user split along: every sample within a hair of the polyline.
|
||||||
let on_split = |ex: &p21::Exchange, e: u64| -> bool {
|
let on_split = |ex: &p21::Exchange, e: u64| -> bool {
|
||||||
let Some(pts) = edge_samples(ex, e) else { return false };
|
let Some(pts) = edge_samples(ex, e) else { return false };
|
||||||
@@ -876,21 +931,10 @@ fn merge_split_faces(ex: &mut p21::Exchange, paint: &mut HashMap<u64, FaceLook>,
|
|||||||
let v = |a: truck_modeling::Vector3| [a.x, a.y, a.z];
|
let v = |a: truck_modeling::Vector3| [a.x, a.y, a.z];
|
||||||
Some(Analytic { kind: AnalyticKind::Plane { o: [f.o.x, f.o.y, f.o.z], z: v(f.z), x: v(f.x) }, flip: false })
|
Some(Analytic { kind: AnalyticKind::Plane { o: [f.o.x, f.o.y, f.o.z], z: v(f.z), x: v(f.x) }, flip: false })
|
||||||
}
|
}
|
||||||
|
// Pieces of a B-spline cylinder or cone merge only when their edges
|
||||||
|
// are circles square to the axis and rulings (an extruded hole).
|
||||||
_ => analytic_bspline(ex, se).filter(|a| match a.kind {
|
_ => analytic_bspline(ex, se).filter(|a| match a.kind {
|
||||||
// Pieces of a B-spline cylinder merge only when their curved edges
|
AnalyticKind::Cylinder { .. } | AnalyticKind::Cone { .. } => square_or_ruled(ex, fe, &a.kind),
|
||||||
// are circles square to the axis (an extruded hole): crossing
|
|
||||||
// curves (a hole through a tube wall) read far more slowly on a
|
|
||||||
// cylinder than on the sheet they came with.
|
|
||||||
AnalyticKind::Cylinder { z, .. } => face_edges(ex, fe).is_some_and(|ls| {
|
|
||||||
ls.iter().flatten().all(|(x, _)| {
|
|
||||||
edge_samples(ex, *x).is_some_and(|pts| {
|
|
||||||
let Some(&q0) = pts.first() else { return false };
|
|
||||||
let tol = 1e-7 * (1.0 + norm(q0));
|
|
||||||
pts.iter().all(|q| dot(sub(*q, q0), z).abs() <= tol)
|
|
||||||
|| pts.iter().all(|q| norm(cross(sub(*q, q0), z)) <= tol)
|
|
||||||
})
|
|
||||||
})
|
|
||||||
}),
|
|
||||||
_ => true,
|
_ => true,
|
||||||
}),
|
}),
|
||||||
}
|
}
|
||||||
@@ -1137,10 +1181,16 @@ fn merge_split_faces(ex: &mut p21::Exchange, paint: &mut HashMap<u64, FaceLook>,
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
// B-spline cylinder sheets under merged faces are written as cylinders (the sheet covers only
|
merged_surfaces
|
||||||
// its own piece), with the parameter seam on the face's seam edge for a full turn, else
|
}
|
||||||
// opposite the face's middle. (Faces replaced by merges stay in the exchange unreferenced:
|
|
||||||
// only the shells' faces count.)
|
/// B-spline cylinder and cone sheets written as CYLINDRICAL_SURFACE and CONICAL_SURFACE (the
|
||||||
|
/// sheet covers only its own piece, and a fillet's may reach far past it), with the direction of
|
||||||
|
/// the parameter seam: on the face's seam edge for a full turn, else opposite the face's middle.
|
||||||
|
/// Sheets under faces merged from pieces always; a lone piece when its edges are circles square
|
||||||
|
/// to the axis and rulings. (Faces replaced by merges stay in the exchange unreferenced: only the
|
||||||
|
/// shells' faces count.)
|
||||||
|
fn analytic_sheets(ex: &p21::Exchange, merged_surfaces: &std::collections::HashSet<u64>) -> HashMap<u64, V3> {
|
||||||
let live: Vec<u64> = ex
|
let live: Vec<u64> = ex
|
||||||
.entities
|
.entities
|
||||||
.values()
|
.values()
|
||||||
@@ -1151,12 +1201,16 @@ fn merge_split_faces(ex: &mut p21::Exchange, paint: &mut HashMap<u64, FaceLook>,
|
|||||||
let mut out = HashMap::new();
|
let mut out = HashMap::new();
|
||||||
for e in live.iter().filter_map(|f| ex.get(*f)) {
|
for e in live.iter().filter_map(|f| ex.get(*f)) {
|
||||||
let Some(sid) = e.params().get(2).and_then(Param::as_ref_id) else { continue };
|
let Some(sid) = e.params().get(2).and_then(Param::as_ref_id) else { continue };
|
||||||
if !merged_surfaces.contains(&sid) || out.contains_key(&sid) {
|
if out.contains_key(&sid) {
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
let Some(Analytic { kind: AnalyticKind::Cylinder { o, z, .. }, .. }) = ex.get(sid).and_then(|se| cylindrical_bspline(ex, se)) else {
|
let Some(Analytic { kind, .. }) = ex.get(sid).and_then(|se| ruled_bspline(ex, se)) else {
|
||||||
continue;
|
continue;
|
||||||
};
|
};
|
||||||
|
let (AnalyticKind::Cylinder { o, z, .. } | AnalyticKind::Cone { o, z, .. }) = kind else { continue };
|
||||||
|
if !merged_surfaces.contains(&sid) && !square_or_ruled(ex, e, &kind) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
let Some(loops) = face_edges(ex, e) else { continue };
|
let Some(loops) = face_edges(ex, e) else { continue };
|
||||||
let radial = |q: V3| {
|
let radial = |q: V3| {
|
||||||
let v = sub(q, o);
|
let v = sub(q, o);
|
||||||
@@ -1167,8 +1221,13 @@ fn merge_split_faces(ex: &mut p21::Exchange, paint: &mut HashMap<u64, FaceLook>,
|
|||||||
.flat_map(|l| l.iter().map(move |(x, _)| (l, *x)))
|
.flat_map(|l| l.iter().map(move |(x, _)| (l, *x)))
|
||||||
.find(|(l, x)| l.iter().filter(|(y, _)| y == x).count() > 1)
|
.find(|(l, x)| l.iter().filter(|(y, _)| y == x).count() > 1)
|
||||||
.map(|(_, x)| x);
|
.map(|(_, x)| x);
|
||||||
let x = match seam.and_then(|edge| ex.get(edge)?.params().get(1)?.as_ref_id()).and_then(|v| vertex_point(ex, v)) {
|
// (A cone tip's seam has one end at the apex, on the axis.)
|
||||||
Some(q) => unit(radial(q)),
|
let seam_dir = seam.and_then(|edge| {
|
||||||
|
let p = ex.get(edge)?.params();
|
||||||
|
[p.get(1), p.get(2)].into_iter().filter_map(|v| vertex_point(ex, v?.as_ref_id()?)).find_map(|q| unit(radial(q)))
|
||||||
|
});
|
||||||
|
let x = match seam_dir {
|
||||||
|
Some(x) => Some(x),
|
||||||
None => {
|
None => {
|
||||||
let mean = loops
|
let mean = loops
|
||||||
.iter()
|
.iter()
|
||||||
@@ -1187,8 +1246,8 @@ fn merge_split_faces(ex: &mut p21::Exchange, paint: &mut HashMap<u64, FaceLook>,
|
|||||||
out
|
out
|
||||||
}
|
}
|
||||||
|
|
||||||
/// The B-rep entities of one body as truck writes them, parsed, and the surfaces of faces
|
/// The B-rep entities of one body as truck writes them, parsed, and the B-spline sheets to write
|
||||||
/// merged from pieces.
|
/// as cylinders and cones (see `analytic_sheets`). Without `merge` the file is truck's, as is.
|
||||||
fn brep_exchange(b: &Body, merge: bool) -> Result<(p21::Exchange, HashMap<u64, V3>, HashMap<u64, FaceLook>)> {
|
fn brep_exchange(b: &Body, merge: bool) -> Result<(p21::Exchange, HashMap<u64, V3>, HashMap<u64, FaceLook>)> {
|
||||||
let text = crate::step::truck_step(&[b], "SolidCraft")?;
|
let text = crate::step::truck_step(&[b], "SolidCraft")?;
|
||||||
let mut ex = p21::parse(&text).map_err(|e| KernelError::Failed(format!("STEP export: {e}")))?;
|
let mut ex = p21::parse(&text).map_err(|e| KernelError::Failed(format!("STEP export: {e}")))?;
|
||||||
@@ -1209,9 +1268,17 @@ fn brep_exchange(b: &Body, merge: bool) -> Result<(p21::Exchange, HashMap<u64, V
|
|||||||
}
|
}
|
||||||
let before = shell_face_count(&ex);
|
let before = shell_face_count(&ex);
|
||||||
let keep = b.split_lines().map(|l| l.as_slice()).unwrap_or(&[]);
|
let keep = b.split_lines().map(|l| l.as_slice()).unwrap_or(&[]);
|
||||||
let merged = if merge { merge_split_faces(&mut ex, &mut paint, keep) } else { Default::default() };
|
let sheets = if merge {
|
||||||
|
let merged = merge_split_faces(&mut ex, &mut paint, keep);
|
||||||
|
let sheets = analytic_sheets(&ex, &merged);
|
||||||
|
// Lone sheets rewritten as analytic surfaces count as changes to check too.
|
||||||
|
MERGES.with(|m| m.set(m.get() + sheets.keys().filter(|s| !merged.contains(s)).count()));
|
||||||
|
sheets
|
||||||
|
} else {
|
||||||
|
Default::default()
|
||||||
|
};
|
||||||
MERGES.with(|m| m.set(m.get() + before.saturating_sub(shell_face_count(&ex))));
|
MERGES.with(|m| m.set(m.get() + before.saturating_sub(shell_face_count(&ex))));
|
||||||
Ok((ex, merged, paint))
|
Ok((ex, sheets, paint))
|
||||||
}
|
}
|
||||||
|
|
||||||
/// The separate pieces of a body for export, each keeping its face colours: a body of several
|
/// The separate pieces of a body for export, each keeping its face colours: a body of several
|
||||||
@@ -1277,9 +1344,9 @@ fn rigid_frame(m: &[[f64; 4]; 4]) -> Result<([f64; 3], [f64; 3], [f64; 3])> {
|
|||||||
pub fn step_export_products(products: &[ExportProduct], root: usize, header: &StepHeader) -> Result<String> {
|
pub fn step_export_products(products: &[ExportProduct], root: usize, header: &StepHeader) -> Result<String> {
|
||||||
MERGES.with(|m| m.set(0));
|
MERGES.with(|m| m.set(0));
|
||||||
let text = products_text(products, root, header, true)?;
|
let text = products_text(products, root, header, true)?;
|
||||||
// Faces merged per surface must read back as cleanly as the pieces they came from (a merge
|
// Faces merged per surface, and sheets rewritten as cylinders and cones, must read back as
|
||||||
// can leave a loop the reader cannot lay out); otherwise the pieces are written. Without a
|
// cleanly as truck's pieces (a merge can leave a loop the reader cannot lay out); otherwise
|
||||||
// merge there is nothing to check.
|
// the pieces are written as truck made them. Without a change there is nothing to check.
|
||||||
let clean = |t: &str| crate::step_in::step_import(t).is_ok_and(|i| i.warnings.is_empty());
|
let clean = |t: &str| crate::step_in::step_import(t).is_ok_and(|i| i.warnings.is_empty());
|
||||||
if MERGES.with(|m| m.get()) > 0 && !clean(&text) {
|
if MERGES.with(|m| m.get()) > 0 && !clean(&text) {
|
||||||
let plain = products_text(products, root, header, false)?;
|
let plain = products_text(products, root, header, false)?;
|
||||||
@@ -1291,7 +1358,7 @@ pub fn step_export_products(products: &[ExportProduct], root: usize, header: &St
|
|||||||
}
|
}
|
||||||
|
|
||||||
thread_local! {
|
thread_local! {
|
||||||
/// Faces merged while writing the current export.
|
/// Faces merged and sheets rewritten while writing the current export.
|
||||||
static MERGES: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
|
static MERGES: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
Reference in new issue
Block a user