//! What analytic surface a face of the schema 4 record lies on, with its outward side, and the //! faces that continue a chosen face on the same surface (a hole's wall stored in halves). //! Moving faces along their normals (offset faces, shell, draft) is SMLib's //! (`crate::offset_backend`). use solidcraft_geom::Vec3; use solidcraft_geom::brep::{Brep, Frame, Loop, Surface}; use crate::body::Body; #[derive(Clone, Copy, Debug)] pub(crate) enum Surf { /// Outward normal and offset: n·x = d. Plane { n: Vec3, d: f64 }, /// Axis point and direction, radius; `convex` when the outward normal points away from /// the axis. Cylinder { o: Vec3, a: Vec3, r: f64, convex: bool }, /// Centre and radius; `convex` when the outward normal points away from the centre. Sphere { c: Vec3, r: f64, convex: bool }, /// Apex, unit axis (into the cone, away from the apex) and half-angle; `convex` when the /// 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. Torus { o: Vec3, a: Vec3, big: f64, h: f64, r: f64, convex: bool }, } fn axes(f: &Frame) -> Option<(Vec3, Vec3)> { let (x, y) = (Vec3::from(f.x_axis), Vec3::from(f.y_axis)); Some((Vec3::from(f.origin), x.cross(y).normalized()?)) } /// What surface face `face` of the record `b` lies on, as its record says (planes, cylinders, /// cones, spheres and tori; `None` for a free-form face). The record's analytic surfaces have /// their natural normals away from their axis or centre, so a face is convex when its shell /// uses its natural side. pub(crate) fn surf_of(b: &Brep, face: usize) -> Option { let f = b.faces.get(face)?; // `forward` is about the face's NURBS form, which may run against its surface. let out = crate::assemble::natural_out(b, face)? != f.form_turns()?; let sign = if out { 1.0 } else { -1.0 }; Some(match &f.surface { Surface::Plane { origin, u_axis, v_axis } => { let n = Vec3::from(*u_axis).cross(Vec3::from(*v_axis)).normalized()? * sign; Surf::Plane { n, d: n.dot(Vec3::from(*origin)) } } Surface::PlaneThrough { origin, u_point, v_point } => { let o = Vec3::from(*origin); let n = (Vec3::from(*u_point) - o).cross(Vec3::from(*v_point) - o).normalized()? * sign; Surf::Plane { n, d: n.dot(o) } } Surface::Cylinder { frame, radius } => { let (o, a) = axes(frame)?; Surf::Cylinder { o, a, r: *radius, convex: out } } Surface::Sphere { frame, radius } => Surf::Sphere { c: Vec3::from(frame.origin), r: *radius, convex: out }, Surface::Cone { frame, radius_at_origin, half_angle } => { let (o, z) = axes(frame)?; let apex = o + z * (-radius_at_origin / half_angle.tan()); let a = if *half_angle > 0.0 { z } else { -z }; Surf::Cone { v: apex, a, half: half_angle.abs(), convex: out } } Surface::Torus { frame, major_radius, minor_radius } => { let (o, a) = axes(frame)?; Surf::Torus { o, a, big: *major_radius, h: 0.0, r: *minor_radius, convex: out } } Surface::Spline { .. } | Surface::RationalSpline { .. } | Surface::PlacedRevolution { .. } => return None, }) } impl Surf { /// Whether `other` is this surface, with the same outward side, within `tol`. pub(crate) fn same(&self, other: &Surf, tol: f64) -> bool { match (*self, *other) { (Surf::Plane { n, d }, Surf::Plane { n: m, d: e }) => n.dot(m) > 1.0 - 1e-9 && (d - e).abs() < tol, (Surf::Cylinder { o, a, r, convex }, Surf::Cylinder { o: o2, a: a2, r: r2, convex: c2 }) => { a.dot(a2).abs() > 1.0 - 1e-9 && (r - r2).abs() < tol && convex == c2 && (o2 - o - a * (o2 - o).dot(a)).len() < tol } (Surf::Sphere { c, r, convex }, Surf::Sphere { c: c2, r: r2, convex: k2 }) => c.dist(c2) < tol && (r - r2).abs() < tol && convex == k2, (Surf::Cone { v, a, half, convex }, Surf::Cone { v: v2, a: a2, half: h2, convex: k2 }) => { v.dist(v2) < tol && a.dot(a2) > 1.0 - 1e-9 && (half - h2).abs() < 1e-9 && convex == k2 } (Surf::Torus { o, a, big, h, r, convex }, Surf::Torus { o: o2, a: a2, big: b2, h: h2, r: r2, convex: k2 }) => { (o + a * h).dist(o2 + a2 * h2) < tol && a.dot(a2).abs() > 1.0 - 1e-9 && (big - b2).abs() < tol && (r - r2).abs() < tol && convex == k2 } _ => false, } } } /// The record edges each face of `b` uses. pub(crate) fn face_edges(b: &Brep, face: usize) -> Vec { let mut out: Vec = b .faces .get(face) .into_iter() .flat_map(|f| &f.loops) .flat_map(|l| match l { Loop::Edges { edges } => edges.iter().map(|u| u.edge).collect(), Loop::Vertex { .. } => Vec::new(), }) .collect(); out.sort_unstable(); out.dedup(); out } /// The chosen faces and every face on the same surface joined to them (the halves of a hole's /// wall), as face indices. Pieces of a face split on purpose (Split Face) stay apart. pub fn with_same_surface(b: &Body, chosen: &[usize]) -> Vec { let Ok(record) = crate::native::brep_record(b) else { return chosen.to_vec() }; let tol = (b.size() * 1e-7).max(1e-9) * 100.0; let surfs: Vec> = (0..record.faces.len()).map(|i| surf_of(&record, i)).collect(); let edges: Vec> = (0..record.faces.len()).map(|i| face_edges(&record, i)).collect(); let keep = b.split_keep(); let mut out: Vec = chosen.to_vec(); let mut grew = true; while grew { grew = false; for i in 0..record.faces.len() { if out.contains(&i) { continue; } let Some(Some(si)) = surfs.get(i) else { continue }; let mine = edges.get(i).map(Vec::as_slice).unwrap_or(&[]); let joins = out.iter().any(|j| { surfs.get(*j).and_then(|x| x.as_ref()).is_some_and(|sj| si.same(sj, tol)) && edges.get(*j).is_some_and(|theirs| { theirs.iter().any(|e| { mine.binary_search(e).is_ok() && (keep.is_empty() || !crate::heal::on_split_line(&crate::heal::edge_points(&record, *e), keep)) }) }) }); if joins { out.push(i); grew = true; } } } out }