use std::collections::HashMap;
use super::geometry::Geometry;
use super::heal;
use super::part21::Param;
use crate::{
Error, Result, check,
geom::{Circle, Curve, Line, Surface},
math::{Frame, Point3, Vec2},
tol,
topo::{Brep, CoedgeSpec, EdgeId, FaceId, PCurve, ShellId, SolidId, VertexId, project_on},
};
fn bad<T>(id: u64, what: &str) -> Result<T> {
Err(Error::InvalidInput(format!("STEP #{id}: {what}")))
}
fn unsupported<T>(id: u64, what: &str) -> Result<T> {
Err(Error::Unsupported(format!("STEP #{id}: {what}")))
}
#[derive(Clone, Copy, Debug)]
pub(super) struct Use {
pub edge: usize,
pub reversed: bool,
}
#[derive(Clone, Debug)]
pub(super) struct RawEdge {
pub id: u64,
pub curve: Curve,
pub start: usize,
pub end: usize,
pub faces: Vec<usize>,
}
#[derive(Clone, Debug)]
pub(super) struct RawFace {
pub id: u64,
pub name: String,
pub surface: Surface,
pub reversed: bool,
pub bounds: Vec<(bool, Vec<Use>)>,
pub points: Vec<usize>,
}
#[derive(Clone, Debug, Default)]
pub(super) struct Raw {
pub points: Vec<Point3>,
pub vertex_ids: Vec<u64>,
pub edges: Vec<RawEdge>,
pub faces: Vec<RawFace>,
pub shells: Vec<Vec<usize>>,
}
pub(super) fn param_of(c: &Curve, p: Point3) -> f64 {
let (d0, d1) = c.domain();
match c.period() {
Some(per) => {
let t = [d0, d0 + 0.5 * per]
.map(|a| c.project(p, a, a + per))
.into_iter()
.min_by(|&a, &b| c.eval(a).dist(p).total_cmp(&c.eval(b).dist(p)))
.unwrap_or(d0);
d0 + (t - d0).rem_euclid(per)
}
None if d0.is_finite() => c.project(p, d0, d1),
None => c.project(p, -1e12, 1e12),
}
}
pub(super) fn edge_range(c: &Curve, ps: Point3, pe: Point3, closed: bool) -> Option<(f64, f64)> {
let (d0, d1) = c.domain();
let t0 = param_of(c, ps);
let mut t1 = param_of(c, pe);
match c.period() {
Some(p) if closed => t1 = t0 + p,
Some(p) => {
t1 = t0 + (t1 - t0).rem_euclid(p);
if (t1 - t0).abs() <= tol::param(c.d1(t0).1.norm()) {
t1 = t0 + p;
}
}
None if closed => return None,
None => {}
}
let snap = |t: f64| {
if c.period().is_some() || !d0.is_finite() {
return t;
}
let near = tol::param(c.d1(t).1.norm());
if (t - d0).abs() <= near {
d0
} else if (t - d1).abs() <= near {
d1
} else {
t
}
};
let (t0, t1) = (snap(t0), snap(t1));
(t1 > t0).then_some((t0, t1))
}
fn without_split(mut raw: Raw, splits: &HashMap<usize, [usize; 2]>) -> Raw {
if splits.is_empty() {
return raw;
}
let mut index = vec![usize::MAX; raw.edges.len()];
let mut kept = Vec::with_capacity(raw.edges.len());
for (i, e) in raw.edges.drain(..).enumerate() {
if !splits.contains_key(&i) {
index[i] = kept.len();
kept.push(e);
}
}
raw.edges = kept;
for f in &mut raw.faces {
for (_, uses) in &mut f.bounds {
for u in uses {
u.edge = index[u.edge];
}
}
}
raw
}
fn join_contacts(mut raw: Raw) -> Raw {
let n = raw.points.len();
let mut parent: Vec<usize> = (0..n).collect();
fn root(p: &mut [usize], mut i: usize) -> usize {
while p[i] != i {
p[i] = p[p[i]];
i = p[i];
}
i
}
let mut order: Vec<usize> = (0..n).collect();
order.sort_by(|&a, &b| raw.points[a].x.total_cmp(&raw.points[b].x));
let mut joined = false;
for (k, &i) in order.iter().enumerate() {
for &j in &order[k + 1..] {
if raw.points[j].x - raw.points[i].x > tol::LINEAR {
break;
}
if raw.points[i].dist(raw.points[j]) <= tol::LINEAR {
let (a, b) = (root(&mut parent, i), root(&mut parent, j));
if a != b {
parent[a.max(b)] = a.min(b);
joined = true;
}
}
}
}
if joined {
let mut index = vec![usize::MAX; n];
let (mut points, mut ids) = (Vec::new(), Vec::new());
for (i, slot) in index.iter_mut().enumerate() {
if root(&mut parent, i) == i {
*slot = points.len();
points.push(raw.points[i]);
ids.push(raw.vertex_ids[i]);
}
}
let at: Vec<usize> = (0..n).map(|i| index[root(&mut parent, i)]).collect();
raw.points = points;
raw.vertex_ids = ids;
for e in &mut raw.edges {
e.start = at[e.start];
e.end = at[e.end];
}
for f in &mut raw.faces {
for v in &mut f.points {
*v = at[*v];
}
}
}
let mut ends: HashMap<(usize, usize), Vec<usize>> = HashMap::new();
for (i, e) in raw.edges.iter().enumerate() {
ends.entry((e.start.min(e.end), e.start.max(e.end)))
.or_default()
.push(i);
}
let m = raw.edges.len();
let mut into: Vec<(usize, bool)> = (0..m).map(|i| (i, false)).collect();
let mut any = false;
for group in ends.values().filter(|g| g.len() > 1) {
for (k, &i) in group.iter().enumerate() {
if into[i].0 != i {
continue;
}
let a = &raw.edges[i];
let (pa, pz) = (raw.points[a.start], raw.points[a.end]);
let Some((t0, t1)) = edge_range(&a.curve, pa, pz, a.start == a.end) else {
continue;
};
let (q, d) = a.curve.d1(0.5 * (t0 + t1));
for &j in &group[k + 1..] {
let b = &raw.edges[j];
if into[j].0 != j {
continue;
}
let (pb, pe) = (raw.points[b.start], raw.points[b.end]);
let Some((u0, u1)) = edge_range(&b.curve, pb, pe, b.start == b.end) else {
continue;
};
let mut t = param_of(&b.curve, q);
if let Some(p) = b.curve.period() {
t = u0 + (t - u0).rem_euclid(p);
}
let (r, dr) = b.curve.d1(t);
if (u0..=u1).contains(&t) && r.dist(q) <= tol::LINEAR {
into[j] = (i, d.dot(dr) < 0.0);
any = true;
}
}
}
}
if !any {
return raw;
}
let mut kept = vec![usize::MAX; m];
let mut edges = Vec::new();
for i in 0..m {
if into[i].0 == i {
kept[i] = edges.len();
edges.push(raw.edges[i].clone());
}
}
for (i, &(to, _)) in into.iter().enumerate() {
if to != i {
let faces = raw.edges[i].faces.clone();
edges[kept[to]].faces.extend(faces);
}
}
raw.edges = edges;
for f in &mut raw.faces {
for (_, uses) in &mut f.bounds {
for u in uses {
let (to, flip) = into[u.edge];
u.edge = kept[to];
u.reversed ^= flip;
}
}
}
raw
}
fn use_start(raw: &Raw, u: &Use) -> usize {
let e = &raw.edges[u.edge];
if u.reversed { e.end } else { e.start }
}
struct Reader<'g, 'a> {
geo: &'g mut Geometry<'a>,
raw: Raw,
vertices: HashMap<u64, usize>,
edges: HashMap<u64, (usize, bool)>,
corners: HashMap<[u64; 3], usize>,
sides: HashMap<(usize, usize), usize>,
splits: HashMap<usize, [usize; 2]>,
}
enum Bound {
Edges(bool, Vec<Use>),
Vertex(usize),
}
impl<'g, 'a> Reader<'g, 'a> {
fn params(&self, id: u64, kinds: &[&str]) -> Result<(&'a str, &'a [Param])> {
let Some(e) = self.geo.file.get(id) else {
return bad(id, "missing instance");
};
for (k, p) in &e.parts {
if kinds.contains(&k.as_str()) {
return Ok((k.as_str(), p.as_slice()));
}
}
unsupported(
id,
&format!("{} where {} was expected", e.kind(), kinds.join(" or ")),
)
}
fn vertex(&mut self, id: u64) -> Result<usize> {
if let Some(&v) = self.vertices.get(&id) {
return Ok(v);
}
let (_, a) = self.params(id, &["VERTEX_POINT"])?;
let p = self.geo.point(self.geo.reference(id, a.get(1))?)?;
self.raw.points.push(p);
self.raw.vertex_ids.push(id);
let v = self.raw.points.len() - 1;
self.vertices.insert(id, v);
Ok(v)
}
fn edge(&mut self, id: u64) -> Result<(usize, bool)> {
if let Some(&e) = self.edges.get(&id) {
return Ok(e);
}
let (_, a) = self.params(id, &["EDGE_CURVE"])?;
let vs = self.vertex(self.geo.reference(id, a.get(1))?)?;
let ve = self.vertex(self.geo.reference(id, a.get(2))?)?;
let curve = self.geo.curve(self.geo.reference(id, a.get(3))?)?;
let flip = a.get(4).and_then(Param::as_bool) == Some(false);
let (start, end) = if flip { (ve, vs) } else { (vs, ve) };
self.raw.edges.push(RawEdge {
id,
curve,
start,
end,
faces: Vec::new(),
});
let e = (self.raw.edges.len() - 1, flip);
self.edges.insert(id, e);
Ok(e)
}
fn corner(&mut self, id: u64) -> Result<usize> {
let p = self.geo.point(id)?;
let key = [p.x.to_bits(), p.y.to_bits(), p.z.to_bits()];
if let Some(&v) = self.corners.get(&key) {
return Ok(v);
}
self.raw.points.push(p);
self.raw.vertex_ids.push(id);
let v = self.raw.points.len() - 1;
self.corners.insert(key, v);
Ok(v)
}
fn poly_loop(&mut self, lp: u64, la: &[Param], forward: bool) -> Result<Vec<Use>> {
let mut corners = Vec::new();
for p in la.get(1).and_then(Param::as_list).unwrap_or(&[]) {
corners.push(self.corner(self.geo.reference(lp, Some(p))?)?);
}
corners.dedup();
while corners.len() > 1 && corners.first() == corners.last() {
corners.pop();
}
if corners.len() < 3 {
return bad(lp, "a polygon needs three distinct corners");
}
let mut uses = Vec::new();
for k in 0..corners.len() {
let (a, b) = (corners[k], corners[(k + 1) % corners.len()]);
let edge = match self.sides.get(&(a.min(b), a.max(b))) {
Some(&e) => e,
None => {
let (pa, pb) = (self.raw.points[a], self.raw.points[b]);
let Some(dir) = (pb - pa).unit() else {
return bad(lp, "a polygon side has no length");
};
self.raw.edges.push(RawEdge {
id: lp,
curve: Curve::Line(Line { origin: pa, dir }),
start: a,
end: b,
faces: Vec::new(),
});
let e = self.raw.edges.len() - 1;
self.sides.insert((a.min(b), a.max(b)), e);
e
}
};
let along = self.raw.edges[edge].start == a;
uses.push(Use {
edge,
reversed: along != forward,
});
}
if !forward {
uses.reverse();
}
Ok(uses)
}
fn bound(&mut self, id: u64, flip_face: bool) -> Result<Bound> {
let (kind, a) = self.params(id, &["FACE_OUTER_BOUND", "FACE_BOUND"])?;
let outer = kind == "FACE_OUTER_BOUND";
let lp = self.geo.reference(id, a.get(1))?;
let orient = a.get(2).and_then(Param::as_bool) != Some(false);
let (lk, la) = self.params(lp, &["EDGE_LOOP", "VERTEX_LOOP", "POLY_LOOP"])?;
match lk {
"VERTEX_LOOP" => {
return Ok(Bound::Vertex(
self.vertex(self.geo.reference(lp, la.get(1))?)?,
));
}
"POLY_LOOP" => {
return Ok(Bound::Edges(
outer,
self.poly_loop(lp, la, orient != flip_face)?,
));
}
_ => {}
}
let mut uses = Vec::new();
for oe in la.get(1).and_then(Param::as_list).unwrap_or(&[]) {
let oe = self.geo.reference(lp, Some(oe))?;
let (_, p) = self.params(oe, &["ORIENTED_EDGE"])?;
let (edge, flip) = self.edge(self.geo.reference(oe, p.get(3))?)?;
let along = p.get(4).and_then(Param::as_bool) != Some(false);
uses.push(Use {
edge,
reversed: ((along == orient) ^ flip_face) == flip,
});
}
if !orient ^ flip_face {
uses.reverse();
}
if uses.is_empty() {
return bad(lp, "empty loop");
}
Ok(Bound::Edges(outer, self.expand(&uses)))
}
fn seam(&mut self, id: u64, surface: &Surface, from: usize, apex: usize) -> Result<usize> {
let (p, q) = (self.raw.points[from], self.raw.points[apex]);
let curve = match surface {
Surface::Cone(_) => match (q - p).unit() {
Some(dir) => Curve::Line(Line { origin: p, dir }),
None => return bad(id, "the vertex loop sits on its face's other bound"),
},
Surface::Sphere(s) => {
let c = s.frame.origin;
let x = p - c;
let y = (q - c) - x.unit_or_zero() * (q - c).dot(x.unit_or_zero());
match Frame::new(c, x.cross(y), x) {
Ok(frame) => Curve::Circle(Circle {
frame,
radius: s.radius,
}),
Err(_) => return bad(id, "the vertex loop is not at a pole of its sphere"),
}
}
other => {
return unsupported(id, &format!("VERTEX_LOOP bound on a {} face", other.kind()));
}
};
self.raw.edges.push(RawEdge {
id,
curve,
start: from,
end: apex,
faces: Vec::new(),
});
Ok(self.raw.edges.len() - 1)
}
fn expand(&self, uses: &[Use]) -> Vec<Use> {
let mut out = Vec::with_capacity(uses.len());
for &u in uses {
match self.splits.get(&u.edge) {
Some(&[a, b]) => {
let halves = [Use { edge: a, ..u }, Use { edge: b, ..u }];
let ordered = if u.reversed {
[halves[1], halves[0]]
} else {
halves
};
out.extend(self.expand(&ordered));
}
None => out.push(u),
}
}
out
}
fn split_edge(&mut self, e: usize, t: f64, bounds: &mut [(bool, Vec<Use>)]) -> usize {
let edge = self.raw.edges[e].clone();
let p = edge.curve.eval(t);
self.raw.points.push(p);
self.raw.vertex_ids.push(edge.id);
let v = self.raw.points.len() - 1;
self.raw.edges.push(RawEdge {
end: v,
..edge.clone()
});
self.raw.edges.push(RawEdge { start: v, ..edge });
let n = self.raw.edges.len();
self.splits.insert(e, [n - 2, n - 1]);
for f in 0..self.raw.faces.len() {
for b in 0..self.raw.faces[f].bounds.len() {
let uses = self.expand(&self.raw.faces[f].bounds[b].1);
self.raw.faces[f].bounds[b].1 = uses;
}
}
for (_, uses) in bounds.iter_mut() {
*uses = self.expand(uses);
}
v
}
fn crossing(&self, frame: &Frame, uses: &[Use], at: f64) -> Option<(usize, f64)> {
let off = |p: Point3| {
let l = frame.to_local(p);
(l.y.atan2(l.x) - at + std::f64::consts::PI).rem_euclid(std::f64::consts::TAU)
- std::f64::consts::PI
};
for u in uses {
let e = &self.raw.edges[u.edge];
let (ps, pe) = (self.raw.points[e.start], self.raw.points[e.end]);
let (t0, t1) = edge_range(&e.curve, ps, pe, e.start == e.end)?;
let n = 64;
for k in 0..n {
let (mut lo, mut hi) = (
t0 + (t1 - t0) * k as f64 / n as f64,
t0 + (t1 - t0) * (k + 1) as f64 / n as f64,
);
let (dl, dh) = (off(e.curve.eval(lo)), off(e.curve.eval(hi)));
if dl.signum() == dh.signum() || dl.abs().max(dh.abs()) > 1.0 {
continue;
}
for _ in 0..100 {
let mid = 0.5 * (lo + hi);
if off(e.curve.eval(mid)).signum() == dl.signum() {
lo = mid;
} else {
hi = mid;
}
}
return Some((u.edge, 0.5 * (lo + hi)));
}
}
None
}
fn swept(&self, frame: &Frame, uses: &[Use]) -> Option<f64> {
let angle = |p: Point3| {
let l = frame.to_local(p);
l.y.atan2(l.x)
};
let mut total = 0.0;
for u in uses {
let e = &self.raw.edges[u.edge];
let (ps, pe) = (self.raw.points[e.start], self.raw.points[e.end]);
let (t0, t1) = edge_range(&e.curve, ps, pe, e.start == e.end)?;
let n = 64;
let mut ts: Vec<f64> = (0..=n)
.map(|k| t0 + (t1 - t0) * k as f64 / n as f64)
.collect();
if u.reversed {
ts.reverse();
}
for w in ts.windows(2) {
let d = angle(e.curve.eval(w[1])) - angle(e.curve.eval(w[0]));
let d = (d + std::f64::consts::PI).rem_euclid(std::f64::consts::TAU)
- std::f64::consts::PI;
if d.abs() > 1.0 {
return None;
}
total += d;
}
}
Some(total)
}
fn seamed_band(
&mut self,
id: u64,
surface: &Surface,
reversed: bool,
bounds: &mut Vec<(bool, Vec<Use>)>,
) -> Option<()> {
let frame = match surface {
Surface::Cylinder(c) => c.frame,
Surface::Cone(c) => c.frame,
Surface::Sphere(s) => s.frame,
Surface::Torus(t) => t.frame,
_ => return None,
};
let full = |w: f64| (w.abs() - std::f64::consts::TAU).abs() < 0.1;
let mut winding = Vec::new();
for (k, (_, uses)) in bounds.iter().enumerate() {
let w = self.swept(&frame, uses)?;
if full(w) {
winding.push((k, w));
}
}
let &[(ka, wa), (kb, wb)] = winding.as_slice() else {
return None;
};
if wa * wb >= 0.0 {
return None;
}
let (a, b) = (&bounds[ka].1, &bounds[kb].1);
let on_line = |p: Point3, q: Point3| {
let (lp, lq) = (frame.to_local(p), frame.to_local(q));
let radial = |l: Point3| (l.x * l.x + l.y * l.y).sqrt();
let (rp, rq) = (radial(lp), radial(lq));
if rp <= tol::LINEAR || rq <= tol::LINEAR {
return false;
}
let (ux, uy) = (lp.x / rp, lp.y / rp);
(lq.x - ux * rq).hypot(lq.y - uy * rq) <= tol::LINEAR
};
let aligned = (0..a.len())
.flat_map(|i| (0..b.len()).map(move |j| (i, j)))
.find(|&(i, j)| {
let at = |u: &Use| self.raw.points[use_start(&self.raw, u)];
on_line(at(&a[i]), at(&b[j]))
});
let (a, b, ia, ib) = match aligned {
Some((i, j)) => (a.clone(), b.clone(), i, j),
None => {
let va = use_start(&self.raw, &a[0]);
let la = frame.to_local(self.raw.points[va]);
let (e, t) = self.crossing(&frame, b, la.y.atan2(la.x))?;
let v = self.split_edge(e, t, bounds);
let (a, b) = (bounds[ka].1.clone(), bounds[kb].1.clone());
let ia = a.iter().position(|u| use_start(&self.raw, u) == va)?;
let ib = b.iter().position(|u| use_start(&self.raw, u) == v)?;
(a, b, ia, ib)
}
};
let (va, vb) = (use_start(&self.raw, &a[ia]), use_start(&self.raw, &b[ib]));
let (pa, pb) = (self.raw.points[va], self.raw.points[vb]);
let la = frame.to_local(pa);
let radial = (frame.x * la.x + frame.y * la.y).unit()?;
let meridian = |centre: Point3, radius: f64, toward_v: bool| {
let normal = radial.cross(frame.z) * if toward_v { 1.0 } else { -1.0 };
Frame::new(centre, normal, radial)
.ok()
.map(|frame| Curve::Circle(Circle { frame, radius }))
};
let curve = match surface {
Surface::Cylinder(_) | Surface::Cone(_) => Curve::Line(Line {
origin: pa,
dir: (pb - pa).unit()?,
}),
Surface::Sphere(s) => {
let v = |p: Point3| {
frame
.to_local(p)
.z
.atan2(frame.to_local(p).x.hypot(frame.to_local(p).y))
};
meridian(s.frame.origin, s.radius, v(pb) > v(pa))?
}
Surface::Torus(t) => {
let toward_v = (wa > 0.0) != reversed;
meridian(frame.origin + radial * t.major, t.minor, toward_v)?
}
_ => return None,
};
self.raw.edges.push(RawEdge {
id,
curve,
start: va,
end: vb,
faces: Vec::new(),
});
let seam = self.raw.edges.len() - 1;
let mut out: Vec<Use> = a[ia..].iter().chain(&a[..ia]).copied().collect();
out.push(Use {
edge: seam,
reversed: false,
});
out.extend(b[ib..].iter().chain(&b[..ib]).copied());
out.push(Use {
edge: seam,
reversed: true,
});
bounds.remove(ka.max(kb));
bounds.remove(ka.min(kb));
bounds.insert(0, (true, out));
Some(())
}
fn capped(
&mut self,
id: u64,
surface: &mut Surface,
reversed: bool,
bounds: &mut [(bool, Vec<Use>)],
) -> Result<bool> {
let (base, sphere) = match &*surface {
Surface::Sphere(s) => (s.frame, true),
Surface::Cone(c) if c.half_angle.abs() > tol::ANGULAR => (c.frame, false),
_ => return Ok(false),
};
let mut found = None;
for (k, (_, uses)) in bounds.iter().enumerate() {
let at_pole = uses.iter().any(|u| {
let l = base.to_local(self.raw.points[use_start(&self.raw, u)]);
l.x.hypot(l.y) <= tol::LINEAR
});
let frame = match uses.as_slice() {
_ if !at_pole => base,
[u] if sphere => match &self.raw.edges[u.edge].curve {
Curve::Circle(c) => match Frame::new(base.origin, c.frame.z, c.frame.x) {
Ok(f) => f,
Err(_) => continue,
},
_ => continue,
},
_ => continue,
};
let Some(w) = self.swept(&frame, uses) else {
continue;
};
if (w.abs() - std::f64::consts::TAU).abs() < 0.1 {
if found.is_some() {
return Ok(false);
}
found = Some((k, frame, w));
}
}
let Some((k, frame, w)) = found else {
return Ok(false);
};
let uses = &bounds[k].1;
let pole = match surface {
Surface::Sphere(s) => {
s.frame = frame;
let up = (w > 0.0) != reversed;
frame.origin + frame.z * if up { s.radius } else { -s.radius }
}
Surface::Cone(c) => c.frame.origin - c.frame.z * (c.radius / c.half_angle.tan()),
_ => return Ok(false),
};
self.raw.points.push(pole);
self.raw.vertex_ids.push(id);
let apex = self.raw.points.len() - 1;
let from = use_start(&self.raw, &uses[0]);
let seam = self.seam(id, surface, from, apex)?;
for reversed in [false, true] {
bounds[k].1.push(Use {
edge: seam,
reversed,
});
}
Ok(true)
}
fn face(&mut self, id: u64, flip_face: bool) -> Result<usize> {
let (_, a) = self.params(id, &["ADVANCED_FACE", "FACE_SURFACE"])?;
let name = a.first().and_then(Param::as_str).unwrap_or("").to_string();
let mut surface = self.geo.surface(self.geo.reference(id, a.get(2))?)?;
let same_sense = a.get(3).and_then(Param::as_bool) != Some(false);
let mut bounds = Vec::new();
let mut apexes = Vec::new();
for bd in a.get(1).and_then(Param::as_list).unwrap_or(&[]) {
match self.bound(self.geo.reference(id, Some(bd))?, flip_face)? {
Bound::Edges(outer, uses) => bounds.push((outer, uses)),
Bound::Vertex(v) => apexes.push(v),
}
}
let (mut apexes, points): (Vec<usize>, Vec<usize>) = apexes
.into_iter()
.partition(|&v| closes_at(&surface, self.raw.points[v]));
for &v in &points {
let p = self.raw.points[v];
let uv = surface.project(p);
if surface.eval(uv.x, uv.y).dist(p) > tol::LINEAR {
return bad(id, "a VERTEX_LOOP off its face's surface");
}
}
if let ([apex], 0, Surface::Sphere(sp)) = (apexes.as_slice(), bounds.len(), &surface) {
let (c, p) = (sp.frame.origin, self.raw.points[*apex]);
let other = c * 2.0 - p;
self.raw.points.push(other);
self.raw.vertex_ids.push(id);
let from = self.raw.points.len() - 1;
let x = (other - c).unit_or_zero();
let Ok(frame) = Frame::new(c, x.cross(sp.frame.x), x) else {
return bad(id, "the vertex loop is not at a pole of its sphere");
};
self.raw.edges.push(RawEdge {
id,
curve: Curve::Circle(Circle {
frame,
radius: sp.radius,
}),
start: from,
end: *apex,
faces: Vec::new(),
});
let seam = self.raw.edges.len() - 1;
bounds.push((
true,
vec![
Use {
edge: seam,
reversed: false,
},
Use {
edge: seam,
reversed: true,
},
],
));
apexes.clear();
}
match (apexes.as_slice(), bounds.len()) {
([], _) => {}
(&[apex], 1) => {
let uses = &bounds[0].1;
let first = uses[0];
let e = &self.raw.edges[first.edge];
let from = if first.reversed { e.end } else { e.start };
let seam = self.seam(id, &surface, from, apex)?;
bounds[0].1.push(Use {
edge: seam,
reversed: false,
});
bounds[0].1.push(Use {
edge: seam,
reversed: true,
});
}
_ => {
return unsupported(
id,
"a vertex loop other than one face's apex beside one other bound",
);
}
}
if bounds.is_empty() {
return unsupported(id, "face without bounds");
}
let reversed = !same_sense ^ flip_face;
if self
.seamed_band(id, &surface, reversed, &mut bounds)
.is_none()
&& apexes.is_empty()
{
self.capped(id, &mut surface, reversed, &mut bounds)?;
}
let f = self.raw.faces.len();
for (_, uses) in &bounds {
for u in uses {
self.raw.edges[u.edge].faces.push(f);
}
}
self.raw.faces.push(RawFace {
id,
name,
surface,
reversed: !same_sense ^ flip_face,
bounds,
points,
});
Ok(f)
}
fn solid(&mut self, id: u64) -> Result<()> {
let Some(e) = self.geo.file.get(id) else {
return bad(id, "missing instance");
};
let (kind, a) = (&e.parts[0].0, &e.parts[0].1);
let mut shells: Vec<u64> = Vec::new();
match kind.as_str() {
"MANIFOLD_SOLID_BREP" | "FACETED_BREP" => {
shells.push(self.geo.reference(id, a.get(1))?)
}
"BREP_WITH_VOIDS" => {
shells.push(self.geo.reference(id, a.get(1))?);
for v in a.get(2).and_then(Param::as_list).unwrap_or(&[]) {
shells.push(self.geo.reference(id, Some(v))?);
}
}
other => return unsupported(id, &format!("solid {other}")),
}
for mut sh in shells {
let mut flip = false;
if let Some(p) = self
.geo
.file
.get(sh)
.and_then(|e| e.part("ORIENTED_CLOSED_SHELL"))
{
flip = p.get(3).and_then(Param::as_bool) == Some(false);
sh = self.geo.reference(sh, p.get(2))?;
}
let (_, p) = self.params(sh, &["CLOSED_SHELL"])?;
let mut faces = Vec::new();
for f in p.get(1).and_then(Param::as_list).unwrap_or(&[]) {
faces.push(self.face(self.geo.reference(sh, Some(f))?, flip)?);
}
self.raw.shells.push(faces);
}
Ok(())
}
}
#[derive(Clone, Debug)]
struct Track {
ts: Vec<f64>,
uvs: Vec<Vec2>,
}
struct Builder {
b: Brep,
vertices: Vec<VertexId>,
edges: Vec<EdgeId>,
}
impl Builder {
fn new(raw: &Raw, ranges: &[(f64, f64)]) -> Builder {
let mut b = Brep::new();
let vertices: Vec<VertexId> = raw.points.iter().map(|&p| b.add_vertex(p)).collect();
let edges = raw
.edges
.iter()
.zip(ranges)
.map(|(e, &r)| b.add_edge(e.curve.clone(), r, vertices[e.start], vertices[e.end]))
.collect();
Builder { b, vertices, edges }
}
fn face(&mut self, f: &RawFace) -> Result<()> {
let surface = &f.surface;
let want = if f.reversed { -1.0 } else { 1.0 };
let single = f.bounds.len() == 1;
let mut tracks: Vec<(bool, &[Use], Vec<Track>)> = Vec::new();
for (outer, uses) in &f.bounds {
let sign = (*outer || single).then_some(want);
let t = self
.track_loop(surface, uses, sign)
.or_else(|| self.track_loop(surface, uses, None));
let Some(t) = t else {
return Err(Error::InvalidInput(format!(
"STEP #{}: a loop of this {} face does not close in its parameters",
f.id,
surface.kind()
)));
};
tracks.push((*outer, uses, t));
}
let areas: Vec<f64> = tracks.iter().map(|(_, _, t)| area2(t)).collect();
let outer = (0..tracks.len())
.filter(|&i| areas[i] * want > 0.0)
.max_by(|&i, &j| {
let key = |k: usize| (tracks[k].0, areas[k].abs());
key(i)
.partial_cmp(&key(j))
.unwrap_or(std::cmp::Ordering::Equal)
})
.unwrap_or(0);
tracks.swap(0, outer);
let (lo, hi) = uv_box(&tracks[0].2);
for (_, _, t) in tracks.iter_mut().skip(1) {
shift_into(surface, t, lo, hi);
}
let face = self.b.add_face(surface.clone(), f.reversed, []);
for (_, uses, ts) in &tracks {
let specs = self.specs(surface, uses, ts);
self.b.add_loop(face, specs);
}
for &p in &f.points {
let v = self.vertices[p];
let mut at = [Track {
ts: vec![0.0],
uvs: vec![surface.project(self.b.vertex(v).point)],
}];
shift_into(surface, &mut at, lo, hi);
let edge = self.b.add_degenerate_edge(v, (0.0, 1.0));
let spec = CoedgeSpec {
edge,
reversed: false,
pcurve: PCurve::Affine {
origin: at[0].uvs[0],
dir: Vec2::ZERO,
},
};
self.b.add_loop(face, vec![spec]);
}
Ok(())
}
fn specs(&mut self, s: &Surface, uses: &[Use], tracks: &[Track]) -> Vec<CoedgeSpec> {
let mut out = Vec::new();
let n = uses.len();
for k in 0..n {
let (edge, reversed) = (self.edges[uses[k].edge], uses[k].reversed);
let tr = &tracks[k];
let pcurve = match (s, &self.b.edge(edge).curve) {
(Surface::Plane(_), Some(Curve::Line(_))) => {
let (t0, t1) = (tr.ts[0], tr.ts[tr.ts.len() - 1]);
let (a, z) = (tr.uvs[0], tr.uvs[tr.uvs.len() - 1]);
let dir = (z - a) / (t1 - t0);
PCurve::Affine {
origin: a - dir * t0,
dir,
}
}
_ => PCurve::Projected { seed: tr.uvs[0] },
};
out.push(CoedgeSpec {
edge,
reversed,
pcurve,
});
let end = tr.uvs[tr.uvs.len() - 1];
let next = tracks[(k + 1) % n].uvs[0];
if gap_is_pole(s, end, next) {
let e = self.b.edge(edge);
let v = if reversed { e.start } else { e.end };
let d = self.b.add_degenerate_edge(v, (0.0, 1.0));
out.push(CoedgeSpec {
edge: d,
reversed: false,
pcurve: PCurve::Affine {
origin: end,
dir: next - end,
},
});
}
}
out
}
fn samples(&self, u: Use) -> (Vec<f64>, Vec<Point3>) {
let e = self.b.edge(self.edges[u.edge]);
let c = e.curve.as_ref().expect("STEP edges have curves");
let (t0, t1) = e.range;
let mut cuts = vec![t0];
cuts.extend(c.breakpoints(t0, t1));
cuts.push(t1);
let per = match c {
Curve::Line(_) => 2,
_ => (16 / (cuts.len() - 1)).max(4),
};
let mut ts = Vec::new();
for w in cuts.windows(2) {
for k in 0..per {
ts.push(w[0] + (w[1] - w[0]) * k as f64 / per as f64);
}
}
ts.push(t1);
if u.reversed {
ts.reverse();
}
let pts = ts.iter().map(|&t| c.eval(t)).collect();
(ts, pts)
}
fn track_loop(&self, s: &Surface, uses: &[Use], sign: Option<f64>) -> Option<Vec<Track>> {
let samples: Vec<(Vec<f64>, Vec<Point3>)> = uses.iter().map(|&u| self.samples(u)).collect();
let start = s.project(samples[0].1[0]);
let mut acc = Vec::with_capacity(uses.len());
self.track_from(s, uses, &samples, 0, start, sign, &mut acc)
.then_some(acc)
}
#[allow(clippy::too_many_arguments)]
fn track_from(
&self,
s: &Surface,
uses: &[Use],
samples: &[(Vec<f64>, Vec<Point3>)],
k: usize,
hint: Vec2,
sign: Option<f64>,
acc: &mut Vec<Track>,
) -> bool {
if k == uses.len() {
let (end, first) = (acc[k - 1].uvs[acc[k - 1].uvs.len() - 1], acc[0].uvs[0]);
let closed = closes(s, end, first) || gap_is_pole(s, end, first);
return closed && sign.is_none_or(|w| area2(acc) * w > 0.0);
}
let (ts, pts) = &samples[k];
let first = s.project_near(pts[0], hint);
let free = pole_free(s, first);
let mut starts = vec![first];
if free != (false, false) && pts.len() > 1 {
let inner = s.project_near(pts[1], hint);
starts.clear();
let shifts = |on: bool, p: Option<f64>| match p {
Some(p) if on => vec![0.0, -p, p],
_ => vec![0.0],
};
for du in shifts(free.0, s.u_period()) {
for dv in shifts(free.1, s.v_period()) {
let mut c = first;
if free.0 {
c.x = inner.x + du;
}
if free.1 {
c.y = inner.y + dv;
}
starts.push(c);
}
}
starts.sort_by(|a, b| a.dist(hint).total_cmp(&b.dist(hint)));
}
for (slit, &st) in [false, true]
.into_iter()
.flat_map(|w| starts.iter().map(move |s| (w, s)))
{
let mut uvs = Vec::with_capacity(pts.len());
uvs.push(st);
for p in &pts[1..] {
let prev = uvs[uvs.len() - 1];
uvs.push(s.project_near(*p, prev));
}
let n = uvs.len();
let curve = self.b.edge(self.edges[uses[k].edge]).curve.as_ref();
if let Some(c) = curve.filter(|_| n > 1) {
if pole_free(s, uvs[0]) != (false, false) {
uvs[0] = project_on(s, c, ts[0], ts[1], st);
}
if pole_free(s, uvs[n - 1]) != (false, false) {
uvs[n - 1] = project_on(s, c, ts[n - 1], ts[n - 2], uvs[n - 2]);
}
}
if coincides_with_twin(uses, acc, k, &uvs) != slit {
continue;
}
let end = uvs[n - 1];
acc.push(Track {
ts: ts.clone(),
uvs,
});
if self.track_from(s, uses, samples, k + 1, end, sign, acc) {
return true;
}
acc.pop();
}
false
}
}
fn coincides_with_twin(uses: &[Use], acc: &[Track], k: usize, uvs: &[Vec2]) -> bool {
let n = uvs.len();
(0..k).any(|j| {
uses[j].edge == uses[k].edge && {
let other = &acc[j].uvs;
other.len() == n && other[n / 2].dist(uvs[n - 1 - n / 2]) < 1e-6
}
})
}
fn pole_free(s: &Surface, uv: Vec2) -> (bool, bool) {
let (_, su, sv) = s.d1(uv.x, uv.y);
(su.norm() <= tol::LINEAR, sv.norm() <= tol::LINEAR)
}
fn closes(s: &Surface, a: Vec2, b: Vec2) -> bool {
let near = |d: f64, p: Option<f64>| p.is_none_or(|p| d.abs() < 0.25 * p);
near(a.x - b.x, s.u_period()) && near(a.y - b.y, s.v_period())
}
fn gap_is_pole(s: &Surface, a: Vec2, b: Vec2) -> bool {
let free = pole_free(s, a);
if free == (false, false) {
return false;
}
let (du, dv) = ((a.x - b.x).abs(), (a.y - b.y).abs());
let (moved, held) = (1e-9, 1e-6);
(free.0 && du > moved && dv <= held) || (free.1 && dv > moved && du <= held)
}
fn area2(tracks: &[Track]) -> f64 {
let pts: Vec<Vec2> = tracks
.iter()
.flat_map(|t| t.uvs[..t.uvs.len() - 1].iter().copied())
.collect();
(0..pts.len())
.map(|i| pts[i].cross(pts[(i + 1) % pts.len()]))
.sum()
}
fn closes_at(s: &Surface, p: Point3) -> bool {
let near = |q: Point3| q.dist(p) <= tol::LINEAR;
match s {
Surface::Cone(c) => near(c.frame.origin - c.frame.z * (c.radius / c.half_angle.tan())),
Surface::Sphere(sp) => {
let (o, z) = (sp.frame.origin, sp.frame.z);
near(o + z * sp.radius) || near(o - z * sp.radius)
}
_ => false,
}
}
fn uv_box(tracks: &[Track]) -> (Vec2, Vec2) {
let mut lo = Vec2::new(f64::INFINITY, f64::INFINITY);
let mut hi = Vec2::new(f64::NEG_INFINITY, f64::NEG_INFINITY);
for p in tracks.iter().flat_map(|t| t.uvs.iter()) {
lo = Vec2::new(lo.x.min(p.x), lo.y.min(p.y));
hi = Vec2::new(hi.x.max(p.x), hi.y.max(p.y));
}
(lo, hi)
}
fn shift_into(s: &Surface, tracks: &mut [Track], lo: Vec2, hi: Vec2) {
let (a, b) = uv_box(tracks);
let c = (a + b) * 0.5;
let shift = |x: f64, lo: f64, hi: f64, p: Option<f64>| -> f64 {
match p {
Some(p) if x < lo || x > hi => ((0.5 * (lo + hi) - x) / p).round() * p,
_ => 0.0,
}
};
let d = Vec2::new(
shift(c.x, lo.x, hi.x, s.u_period()),
shift(c.y, lo.y, hi.y, s.v_period()),
);
if d.x != 0.0 || d.y != 0.0 {
for t in tracks {
for uv in &mut t.uvs {
*uv = *uv + d;
}
}
}
}
pub(super) type ReadSolid = (Brep, Vec<(u64, String)>, Option<heal::Healed>);
pub(super) fn solid(geo: &mut Geometry, id: u64) -> Result<ReadSolid> {
if geo
.file
.get(id)
.is_some_and(|e| e.part("TESSELLATED_SOLID").is_some())
{
return tessellated(geo, id).map(|b| {
let names = vec![(0, String::new()); b.face_count()];
(b, names, None)
});
}
let mut rd = Reader {
geo,
raw: Raw::default(),
vertices: HashMap::new(),
edges: HashMap::new(),
corners: HashMap::new(),
sides: HashMap::new(),
splits: HashMap::new(),
};
rd.solid(id)?;
let uncertainty = rd.geo.uncertainty();
let file = join_contacts(without_split(rd.raw, &rd.splits));
let mut raw = file.clone();
let names = || file.faces.iter().map(|f| (f.id, f.name.clone())).collect();
let exact = heal::heal(&mut raw)
.and_then(|(ranges, healed)| assemble(&raw, &ranges, None).map(|b| (b, healed)));
let within = uncertainty.filter(|&u| u > tol::LINEAR);
let why = match exact {
Ok((b, healed)) if within.is_none_or(|w| healed.as_ref().is_none_or(|h| h.moved <= w)) => {
return Ok((b, names(), healed));
}
Ok((b, healed)) => Ok((b, healed)),
Err(e) => Err(e),
};
let tolerant = |raw: &Raw| {
let mut raw = raw.clone();
heal::tolerate(&mut raw, within)
.map_err(|t| format!("kept as the file has it, {t}"))
.and_then(|t| {
assemble(&raw, &t.ranges, Some(&t))
.map_err(|e| format!("kept as the file has it, with local tolerances: {e}"))
})
};
match (tolerant(&file), why) {
(Ok(b), _) => Ok((b, names(), None)),
(Err(_), Ok((b, healed))) => Ok((b, names(), healed)),
(Err(t), Err(e)) => {
let mut loose = file.clone();
let healed = heal::heal_loosely(&mut loose);
let l = match (tolerant(&loose), healed.as_ref(), within) {
(Ok(_), Some(h), Some(within)) if h.moved > within => format!(
"healing would move {} {:.1e} mm, more than the file's {within:.1e} mm",
h.what, h.moved
),
(Ok(b), _, _) => return Ok((b, names(), healed)),
(Err(l), _, _) => l,
};
Err(Error::InvalidInput(format!(
"{e}; {t}; healed where it can be and {l}"
)))
}
}
}
fn assemble(raw: &Raw, ranges: &[(f64, f64)], tolerated: Option<&heal::Tolerated>) -> Result<Brep> {
let mut b = build(raw, ranges, tolerated)?;
let turned = check::turned_shells(&b);
if !turned.is_empty() {
b = build(&turned_round(raw, &turned), ranges, tolerated)?;
}
let issues = check::check_structure(&b);
if !issues.is_empty() {
return Err(Error::InvalidResult(
issues.into_iter().map(|i| i.to_string()).collect(),
));
}
Ok(b)
}
fn turned_round(raw: &Raw, turned: &[(SolidId, ShellId, bool)]) -> Raw {
let mut raw = raw.clone();
for &(_, sh, _) in turned {
for &f in &raw.shells[sh.index()].clone() {
let face = &mut raw.faces[f];
face.reversed = !face.reversed;
for (_, uses) in &mut face.bounds {
uses.reverse();
for u in uses.iter_mut() {
u.reversed = !u.reversed;
}
}
}
}
raw
}
fn build(raw: &Raw, ranges: &[(f64, f64)], tolerated: Option<&heal::Tolerated>) -> Result<Brep> {
let mut bld = Builder::new(raw, ranges);
if let Some(t) = tolerated {
for (v, &x) in t.vertices.iter().enumerate() {
bld.b.set_vertex_tolerance(bld.vertices[v], x);
}
for (e, &x) in t.edges.iter().enumerate() {
bld.b.set_edge_tolerance(bld.edges[e], x);
}
}
for f in &raw.faces {
bld.face(f)?;
}
let mut b = bld.b;
let mut base = 0;
let mut shells = Vec::new();
for sh in &raw.shells {
let ids: Vec<_> = b.face_ids().skip(base).take(sh.len()).collect();
base += sh.len();
shells.push(b.add_shell(ids));
}
b.add_solid(shells);
b.pair_radial();
Ok(b)
}
fn tessellated(geo: &mut Geometry, id: u64) -> Result<Brep> {
let unit = geo.length_unit();
let Some(solid) = geo
.file
.get(id)
.and_then(|e| e.part("TESSELLATED_SOLID"))
.map(<[Param]>::to_vec)
else {
return bad(id, "expected a tessellated solid");
};
let mut points: Vec<Point3> = Vec::new();
let mut index: HashMap<(u64, usize), usize> = HashMap::new();
let mut triangles: Vec<[usize; 3]> = Vec::new();
for item in solid.get(1).and_then(Param::as_list).unwrap_or(&[]) {
let fid = geo.reference(id, Some(item))?;
let Some(face) = geo
.file
.get(fid)
.and_then(|e| e.part("TRIANGULATED_FACE"))
.map(<[Param]>::to_vec)
else {
return unsupported(fid, "a tessellated face other than a triangulated one");
};
let list = geo.reference(fid, face.get(1))?;
let Some(coords) = geo
.file
.get(list)
.and_then(|e| e.part("COORDINATES_LIST"))
.map(<[Param]>::to_vec)
else {
return bad(list, "expected a coordinates list");
};
let mut xyz = Vec::new();
for c in coords.get(2).and_then(Param::as_list).unwrap_or(&[]) {
let v = geo.numbers(list, Some(c))?;
if v.len() != 3 || v.iter().any(|x| !x.is_finite()) {
return bad(list, "expected three finite coordinates");
}
xyz.push(Point3::new(v[0], v[1], v[2]) * unit);
}
let own: Vec<usize> = face
.get(5)
.and_then(Param::as_list)
.unwrap_or(&[])
.iter()
.map(|p| p.as_i64().map_or(0, |i| i as usize))
.collect();
let corner = |k: i64| -> Option<usize> {
let k = usize::try_from(k).ok()?.checked_sub(1)?;
let i = if own.is_empty() {
k
} else {
own.get(k)?.checked_sub(1)?
};
(i < xyz.len()).then_some(i)
};
for tri in face.get(6).and_then(Param::as_list).unwrap_or(&[]) {
let ks: Vec<i64> = tri
.as_list()
.unwrap_or(&[])
.iter()
.filter_map(Param::as_i64)
.collect();
let idx: Option<Vec<usize>> = ks.iter().map(|&k| corner(k)).collect();
let Some(idx) = idx.filter(|v| v.len() == 3) else {
return bad(fid, "a triangle needs three corners in its list");
};
let mut corners = [0; 3];
for (corner, &i) in corners.iter_mut().zip(&idx) {
*corner = *index.entry((list, i)).or_insert_with(|| {
points.push(xyz[i]);
points.len() - 1
});
}
triangles.push(corners);
}
}
if triangles.is_empty() {
return bad(id, "a tessellated solid with no triangles");
}
crate::mesh::from_indexed(&points, &triangles)
}
pub(super) fn sew(geo: &mut Geometry, tolerance: f64) -> Result<Brep> {
let shells: Vec<u64> = geo
.file
.ids
.iter()
.zip(&geo.file.entities)
.filter(|(_, e)| matches!(e.kind(), "OPEN_SHELL" | "CLOSED_SHELL"))
.map(|(&id, _)| id)
.collect();
let mut rd = Reader {
geo,
raw: Raw::default(),
vertices: HashMap::new(),
edges: HashMap::new(),
corners: HashMap::new(),
sides: HashMap::new(),
splits: HashMap::new(),
};
let mut faces = Vec::new();
for sh in shells {
let (_, p) = rd.params(sh, &["OPEN_SHELL", "CLOSED_SHELL"])?;
for f in p.get(1).and_then(Param::as_list).unwrap_or(&[]) {
faces.push(rd.face(rd.geo.reference(sh, Some(f))?, false)?);
}
}
if faces.is_empty() {
return Err(Error::InvalidInput(
"STEP: the file holds no faces to sew".into(),
));
}
let mut raw = without_split(rd.raw, &rd.splits);
let n = raw.points.len();
let mut rep: Vec<usize> = (0..n).collect();
fn root(rep: &mut [usize], i: usize) -> usize {
let mut r = i;
while rep[r] != r {
r = rep[r];
}
rep[i] = r;
r
}
for i in 0..n {
for j in i + 1..n {
if raw.points[i].dist(raw.points[j]) <= tolerance {
let (a, b) = (root(&mut rep, i), root(&mut rep, j));
if a != b {
rep[b] = a;
}
}
}
}
let mut sum: HashMap<usize, (Point3, f64)> = HashMap::new();
for i in 0..n {
let r = root(&mut rep, i);
let e = sum.entry(r).or_insert((Point3::ZERO, 0.0));
e.0 += raw.points[i];
e.1 += 1.0;
}
for i in 0..n {
let r = root(&mut rep, i);
let (s, k) = sum[&r];
raw.points[i] = s * (1.0 / k);
}
let ends = |e: &RawEdge, rep: &mut [usize]| (root(rep, e.start), root(rep, e.end));
let mut keep: Vec<usize> = (0..raw.edges.len()).collect();
let mut turned = vec![false; raw.edges.len()];
for i in 0..raw.edges.len() {
if keep[i] != i {
continue;
}
let (a, b) = ends(&raw.edges[i], &mut rep);
let mid = |e: &RawEdge| {
let (s, z) = (raw.points[e.start], raw.points[e.end]);
let t = param_of(&e.curve, s.lerp(z, 0.5));
e.curve.eval(t)
};
let mi = mid(&raw.edges[i]);
for j in i + 1..raw.edges.len() {
if keep[j] != j {
continue;
}
let (c, d) = ends(&raw.edges[j], &mut rep);
let same = (a, b) == (c, d);
if !(same || (a, b) == (d, c)) || mid(&raw.edges[j]).dist(mi) > tolerance {
continue;
}
keep[j] = i;
turned[j] = !same;
}
}
for f in &mut raw.faces {
for (_, uses) in &mut f.bounds {
for u in uses.iter_mut() {
if keep[u.edge] != u.edge {
u.reversed ^= turned[u.edge];
u.edge = keep[u.edge];
}
}
}
}
for e in &mut raw.edges {
e.start = root(&mut rep, e.start);
e.end = root(&mut rep, e.end);
}
let mut uses: HashMap<usize, Vec<(usize, bool)>> = HashMap::new();
for (fi, f) in raw.faces.iter().enumerate() {
for (_, us) in &f.bounds {
for u in us {
uses.entry(u.edge).or_default().push((fi, u.reversed));
}
}
}
let mut flip: Vec<Option<bool>> = vec![None; raw.faces.len()];
for start in 0..raw.faces.len() {
if flip[start].is_some() {
continue;
}
flip[start] = Some(false);
let mut stack = vec![start];
while let Some(f) = stack.pop() {
let mine = flip[f].unwrap_or(false);
for (_, us) in &raw.faces[f].bounds {
for u in us {
for &(g, rev) in uses.get(&u.edge).into_iter().flatten() {
if g == f || flip[g].is_some() {
continue;
}
let want = (u.reversed ^ mine) == rev;
flip[g] = Some(want);
stack.push(g);
}
}
}
}
}
for (f, t) in raw.faces.iter_mut().zip(&flip) {
if *t == Some(true) {
f.reversed = !f.reversed;
for (_, us) in &mut f.bounds {
us.reverse();
for u in us.iter_mut() {
u.reversed = !u.reversed;
}
}
}
}
let mut edge_at = vec![usize::MAX; raw.edges.len()];
let mut edges = Vec::new();
for (i, e) in raw.edges.drain(..).enumerate() {
if keep[i] == i {
edge_at[i] = edges.len();
edges.push(e);
}
}
raw.edges = edges;
for f in &mut raw.faces {
for (_, us) in &mut f.bounds {
for u in us.iter_mut() {
u.edge = edge_at[u.edge];
}
}
}
let mut point_at = vec![usize::MAX; raw.points.len()];
let (mut points, mut ids) = (Vec::new(), Vec::new());
for e in &mut raw.edges {
for v in [&mut e.start, &mut e.end] {
if point_at[*v] == usize::MAX {
point_at[*v] = points.len();
points.push(raw.points[*v]);
ids.push(raw.vertex_ids[*v]);
}
*v = point_at[*v];
}
}
for f in &mut raw.faces {
for p in &mut f.points {
*p = root(&mut rep, *p);
if point_at[*p] == usize::MAX {
point_at[*p] = points.len();
points.push(raw.points[*p]);
ids.push(raw.vertex_ids[*p]);
}
*p = point_at[*p];
}
}
raw.points = points;
raw.vertex_ids = ids;
raw.edges.iter_mut().for_each(|e| e.faces.clear());
for (fi, f) in raw.faces.iter().enumerate() {
for (_, us) in &f.bounds {
for u in us {
raw.edges[u.edge].faces.push(fi);
}
}
}
raw.shells = vec![(0..raw.faces.len()).collect()];
let (ranges, _) = heal::heal(&mut raw)?;
assemble(&raw, &ranges, None)
}
pub(crate) fn rebuilt(
b: &Brep,
points: Vec<Point3>,
curves: Vec<Option<Curve>>,
surfaces: Vec<Surface>,
turned: bool,
) -> Result<Brep> {
let mut raw = Raw {
vertex_ids: (0..points.len() as u64).collect(),
points,
..Raw::default()
};
let mut edge_at = vec![usize::MAX; curves.len()];
for ((e, id), c) in b.edge_ids().enumerate().zip(curves) {
if let Some(curve) = c {
let x = b.edge(id);
edge_at[e] = raw.edges.len();
raw.edges.push(RawEdge {
id: e as u64,
curve,
start: x.start.index(),
end: x.end.index(),
faces: Vec::new(),
});
}
}
let faces: Vec<FaceId> = b
.face_ids()
.filter(|&f| b.face(f).shell.is_some())
.collect();
for (&f, surface) in faces.iter().zip(surfaces) {
let face = b.face(f);
let mut bounds = Vec::new();
for (k, &l) in face.loops.iter().enumerate() {
let mut uses: Vec<Use> = b
.lp(l)
.coedges
.iter()
.map(|&c| b.coedge(c))
.filter(|c| edge_at[c.edge.index()] != usize::MAX)
.map(|c| Use {
edge: edge_at[c.edge.index()],
reversed: c.reversed ^ turned,
})
.collect();
if turned {
uses.reverse();
}
for u in &uses {
raw.edges[u.edge].faces.push(raw.faces.len());
}
bounds.push((k == 0, uses));
}
raw.faces.push(RawFace {
id: f.index() as u64,
name: String::new(),
surface,
reversed: face.reversed ^ turned,
bounds,
points: Vec::new(),
});
}
for sh in b.shell_ids() {
let ids = &b.shell(sh).faces;
raw.shells.push(
ids.iter()
.filter_map(|f| faces.iter().position(|g| g == f))
.collect(),
);
}
let (ranges, _) = heal::heal(&mut raw)?;
let mut out = assemble(&raw, &ranges, None)?;
for (g, &f) in out.face_ids().collect::<Vec<_>>().into_iter().zip(&faces) {
out.set_face_names(g, b.face(f).names.clone());
}
Ok(out)
}
#[derive(Clone, Debug, Default)]
pub(crate) struct Parts {
pub points: Vec<Point3>,
pub edges: Vec<(Curve, usize, usize)>,
pub faces: Vec<PartFace>,
}
#[derive(Clone, Debug)]
pub(crate) struct PartFace {
pub surface: Surface,
pub reversed: bool,
pub loops: Vec<Vec<(usize, bool)>>,
pub names: std::collections::BTreeSet<crate::topo::FaceName>,
pub shell: usize,
}
pub(crate) fn parts_of(b: &Brep) -> Result<Parts> {
let mut solids = b.solid_ids();
let (Some(solid), None) = (solids.next(), solids.next()) else {
return Err(Error::Unsupported("the parts of several solids".into()));
};
let solid = b.solid(solid);
if solid.outer != 1 {
return Err(Error::Unsupported(
"the parts of a solid that touches itself".into(),
));
}
let mut parts = Parts {
points: b.vertex_ids().map(|v| b.vertex(v).point).collect(),
..Parts::default()
};
let mut edge_at = vec![usize::MAX; b.edge_ids().count()];
for e in b.edge_ids() {
let x = b.edge(e);
if let Some(curve) = &x.curve {
edge_at[e.index()] = parts.edges.len();
parts
.edges
.push((curve.clone(), x.start.index(), x.end.index()));
}
}
for (shell, &sh) in solid.shells.iter().enumerate() {
for &f in &b.shell(sh).faces {
let face = b.face(f);
let loops = face
.loops
.iter()
.map(|&l| {
b.lp(l)
.coedges
.iter()
.map(|&c| b.coedge(c))
.filter(|c| edge_at[c.edge.index()] != usize::MAX)
.map(|c| (edge_at[c.edge.index()], c.reversed))
.collect()
})
.collect();
parts.faces.push(PartFace {
surface: face.surface.clone(),
reversed: face.reversed,
loops,
names: face.names.clone(),
shell,
});
}
}
Ok(parts)
}
pub(crate) fn solid_of(parts: &Parts) -> Result<Brep> {
let mut raw = Raw::default();
let mut edge_at = vec![usize::MAX; parts.edges.len()];
let mut point_at = vec![usize::MAX; parts.points.len()];
let mut order: Vec<usize> = (0..parts.faces.len()).collect();
order.sort_by_key(|&f| parts.faces[f].shell);
for (fi, &at) in order.iter().enumerate() {
let f = &parts.faces[at];
let mut bounds = Vec::new();
for (k, l) in f.loops.iter().enumerate() {
let mut uses = Vec::new();
for &(e, reversed) in l {
if edge_at[e] == usize::MAX {
let (curve, start, end) = &parts.edges[e];
let mut ends = [*start, *end];
for v in &mut ends {
if point_at[*v] == usize::MAX {
point_at[*v] = raw.points.len();
raw.vertex_ids.push(raw.points.len() as u64);
raw.points.push(parts.points[*v]);
}
*v = point_at[*v];
}
edge_at[e] = raw.edges.len();
raw.edges.push(RawEdge {
id: e as u64,
curve: curve.clone(),
start: ends[0],
end: ends[1],
faces: Vec::new(),
});
}
raw.edges[edge_at[e]].faces.push(fi);
uses.push(Use {
edge: edge_at[e],
reversed,
});
}
bounds.push((k == 0, uses));
}
raw.faces.push(RawFace {
id: fi as u64,
name: String::new(),
surface: f.surface.clone(),
reversed: f.reversed,
bounds,
points: Vec::new(),
});
if raw.shells.len() <= f.shell {
raw.shells.resize(f.shell + 1, Vec::new());
}
raw.shells[f.shell].push(fi);
}
let (ranges, _) = heal::heal(&mut raw)?;
let mut out = assemble(&raw, &ranges, None)?;
for (g, &at) in out.face_ids().collect::<Vec<_>>().into_iter().zip(&order) {
out.set_face_names(g, parts.faces[at].names.clone());
}
Ok(out)
}