329 lines
16 KiB
Rust
329 lines
16 KiB
Rust
//! Sketches made from a planar body face, so a face can be extruded like a profile (Extrude
|
|
//! with `face`, Press Pull). The face boundary is copied into a new sketch on the face: straight
|
|
//! edges become lines, circular edges circles or arcs, anything else a chain of lines.
|
|
|
|
use serde_json::{Value, json};
|
|
use solidcraft_doc::{EmbossFace, apply_point, mat_inverse, mat_mul};
|
|
use solidcraft_geom::{Mesh, Vec2, Vec3};
|
|
|
|
use crate::params::{bad, vec3};
|
|
use crate::{Result, Session};
|
|
|
|
fn point_triangle_dist(p: Vec3, a: Vec3, b: Vec3, c: Vec3) -> f64 {
|
|
let n = (b - a).cross(c - a);
|
|
let Some(nn) = n.normalized() else { return f64::INFINITY };
|
|
let h = (p - a).dot(nn);
|
|
let q = p - nn * h;
|
|
let inside = [(a, b), (b, c), (c, a)].iter().all(|(u, v)| (*v - *u).cross(q - *u).dot(n) >= -1e-12);
|
|
if inside { h.abs() } else { [(a, b), (b, c), (c, a)].iter().map(|(u, v)| p.dist_to_segment(*u, *v)).fold(f64::INFINITY, f64::min) }
|
|
}
|
|
|
|
/// The outward normal of the planar body face at `p`.
|
|
pub(super) fn face_normal(s: &Session, p: Vec3) -> Option<Vec3> {
|
|
face_normal_in(s, p, None)
|
|
}
|
|
|
|
/// The outward normal of the planar face at `p` of `body` (any body when `None`).
|
|
pub(super) fn face_normal_in(s: &Session, p: Vec3, body: Option<&str>) -> Option<Vec3> {
|
|
let (m, f, d, _) = face_at_in(s, p, body).ok().flatten()?;
|
|
let tol = (m.bounds().diagonal() * 1e-3).max(1e-3);
|
|
if d > tol * 10.0 {
|
|
return None;
|
|
}
|
|
m.triangles
|
|
.iter()
|
|
.zip(&m.tri_face)
|
|
.filter(|(_, tf)| **tf == f)
|
|
.filter_map(|(t, _)| m.tri(t))
|
|
.find_map(|[a, b, c]| (b - a).cross(c - a).normalized())
|
|
}
|
|
|
|
/// Is the body face at `p` planar (`None`: no face there)?
|
|
pub(super) fn face_is_planar(s: &Session, p: Vec3) -> Option<bool> {
|
|
let (m, f, d, _) = face_at(s, p)?;
|
|
let tol = (m.bounds().diagonal() * 1e-3).max(1e-3);
|
|
if d > tol * 10.0 {
|
|
return None;
|
|
}
|
|
let ns: Vec<Vec3> = m
|
|
.triangles
|
|
.iter()
|
|
.zip(&m.tri_face)
|
|
.filter(|(_, tf)| **tf == f)
|
|
.filter_map(|(t, _)| m.tri(t))
|
|
.filter_map(|[a, b, c]| (b - a).cross(c - a).normalized())
|
|
.collect();
|
|
let n0 = *ns.first()?;
|
|
Some(ns.iter().all(|n| n.dot(n0) > 1.0 - 1e-6))
|
|
}
|
|
|
|
/// A face given to a command: a point `[x, y, z]` on it (or `{point}`), or its name as
|
|
/// `model.faces` lists it, looked up on `body` (any body without one). A name becomes a point on
|
|
/// that face, which the feature keeps like a picked one, so it also keeps the face's name.
|
|
/// The point is in the frame of the command's other picks: the component's own when
|
|
/// they were mapped into it, else the world's.
|
|
pub(super) fn face_ref(s: &Session, v: &Value, body: Option<&str>, cmd: &str) -> Result<Vec3> {
|
|
if let Some(name) = v.as_str() {
|
|
if name.is_empty() || name.len() > 512 {
|
|
return Err(bad(cmd, "a face name is 1…512 characters"));
|
|
}
|
|
let st = if crate::frames::mapped() { s.model.state() } else { s.world_state() };
|
|
return solidcraft_doc::naming::named_face_point(&st, body, name).map_err(|why| bad(cmd, why));
|
|
}
|
|
vec3(v).or_else(|| v.get("point").and_then(vec3)).ok_or_else(|| bad(cmd, "a face is a point [x, y, z] on it, or its name from model.faces"))
|
|
}
|
|
|
|
/// The body face under a point: (mesh, face index, distance, body).
|
|
fn face_at(s: &Session, p: Vec3) -> Option<(std::sync::Arc<Mesh>, u32, f64, String)> {
|
|
face_at_in(s, p, None).ok().flatten()
|
|
}
|
|
|
|
type FacePick = (std::sync::Arc<Mesh>, u32, f64, String);
|
|
|
|
/// The face under a point of `only` (any body when `None`). Where faces of several bodies are
|
|
/// equally near (bodies touching flush), the pick is ambiguous: `Err` names those bodies.
|
|
fn face_at_in(s: &Session, p: Vec3, only: Option<&str>) -> std::result::Result<Option<FacePick>, Vec<String>> {
|
|
let st = s.model.state();
|
|
face_at_state(&st, p, only)
|
|
}
|
|
|
|
pub(super) fn face_at_state(st: &solidcraft_doc::ModelState, p: Vec3, only: Option<&str>) -> std::result::Result<Option<FacePick>, Vec<String>> {
|
|
let mut best: Option<FacePick> = None;
|
|
let mut tied: Vec<String> = Vec::new();
|
|
for b in st.bodies.iter().filter(|b| only.is_none_or(|n| b.name == n)) {
|
|
let m = b.mesh();
|
|
let mut near: Option<(u32, f64)> = None;
|
|
for (t, f) in m.triangles.iter().zip(&m.tri_face) {
|
|
let Some([a, bb, c]) = m.tri(t) else { continue };
|
|
let d = point_triangle_dist(p, a, bb, c);
|
|
if near.is_none_or(|(_, nd)| d < nd) {
|
|
near = Some((*f, d));
|
|
}
|
|
}
|
|
if let Some((f, d)) = near {
|
|
if best.as_ref().is_none_or(|x| d < x.2 - 1e-8) {
|
|
best = Some((m.clone(), f, d, b.name.clone()));
|
|
tied.clear();
|
|
} else if best.as_ref().is_some_and(|x| (d - x.2).abs() <= 1e-8) {
|
|
tied.push(b.name.clone());
|
|
}
|
|
}
|
|
}
|
|
match best {
|
|
Some(b) if !tied.is_empty() => Err(std::iter::once(b.3).chain(tied).collect()),
|
|
b => Ok(b),
|
|
}
|
|
}
|
|
|
|
/// Circle through three points.
|
|
fn circumcircle(a: Vec2, b: Vec2, c: Vec2) -> Option<(Vec2, f64)> {
|
|
let d = 2.0 * (a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y));
|
|
if d.abs() < 1e-12 {
|
|
return None;
|
|
}
|
|
let (a2, b2, c2) = (a.len2(), b.len2(), c.len2());
|
|
let o = Vec2::new((a2 * (b.y - c.y) + b2 * (c.y - a.y) + c2 * (a.y - b.y)) / d, (a2 * (c.x - b.x) + b2 * (a.x - c.x) + c2 * (b.x - a.x)) / d);
|
|
let r = o.dist(a);
|
|
(o.is_finite() && r.is_finite() && r < 1e8).then_some((o, r))
|
|
}
|
|
|
|
fn xy(v: Vec2) -> Value {
|
|
json!([v.x, v.y])
|
|
}
|
|
|
|
/// Coplanar faces share one linked profile sketch and one Extrude feature. Resolve every
|
|
/// pick before editing the document, so later picks never search an already modified body.
|
|
pub(super) fn sketch_of_faces(s: &mut Session, points: &[Vec3], cmd: &str, face_body: Option<&str>) -> Result<(u64, Vec<Vec2>, String)> {
|
|
let first = points.first().copied().ok_or_else(|| bad(cmd, "faces must not be empty"))?;
|
|
if points.len() > 1024 {
|
|
return Err(bad(cmd, "faces exceed the 1024-face limit"));
|
|
}
|
|
let state = s.model.state();
|
|
let mut picked = Vec::new();
|
|
let mut common: Option<(String, solidcraft_geom::Plane)> = None;
|
|
for &point in points {
|
|
if !point.is_finite() {
|
|
return Err(bad(cmd, "faces must be finite points"));
|
|
}
|
|
let (mesh, index, distance, name) = face_at_in(s, point, face_body)
|
|
.map_err(|_| bad(cmd, "ambiguous face; specify face_body"))?
|
|
.ok_or_else(|| bad(cmd, "no body face at a selected point"))?;
|
|
let body = state.body(&name).ok_or_else(|| bad(cmd, "selected body disappeared"))?;
|
|
let plane = body.body.planar_face(index as usize).ok_or_else(|| bad(cmd, "faces must be planar"))?;
|
|
let tolerance = (body.body.size() * 1e-9).max(1e-8);
|
|
if distance > (mesh.bounds().diagonal() * 1e-3).max(1e-3) * 10.0 {
|
|
return Err(bad(cmd, "no body face at a selected point"));
|
|
}
|
|
if let Some((previous, base)) = &common {
|
|
if *previous != name || base.normal().dot(plane.normal()) < 1.0 - 1e-9 || base.height(plane.origin).abs() > tolerance {
|
|
return Err(bad(cmd, "faces must be coplanar, equally oriented faces of one body"));
|
|
}
|
|
} else {
|
|
common = Some((name.clone(), plane));
|
|
}
|
|
if picked.iter().any(|(face, _)| *face == index as usize) {
|
|
continue;
|
|
}
|
|
let inside = mesh
|
|
.triangles
|
|
.iter()
|
|
.zip(&mesh.tri_face)
|
|
.filter(|(_, face)| **face == index)
|
|
.filter_map(|(triangle, _)| mesh.tri(triangle))
|
|
.max_by(|[a, b, c], [x, y, z]| ((*b - *a).cross(*c - *a).len()).total_cmp(&((*y - *x).cross(*z - *x).len())))
|
|
.map(|[a, b, c]| (a + b + c) / 3.0)
|
|
.ok_or_else(|| bad(cmd, "degenerate face"))?;
|
|
picked.push((index as usize, inside));
|
|
}
|
|
let (id, first_inside, _) = sketch_of_face(s, first, cmd, face_body)?;
|
|
let (body, _) = common.ok_or_else(|| bad(cmd, "no faces selected"))?;
|
|
let doc = s.placed_document();
|
|
let source = state.body(&body).ok_or_else(|| bad(cmd, "source body disappeared"))?;
|
|
let component = doc.model_body_component(source);
|
|
let path = if component == s.active_component {
|
|
s.active_occurrence_path.clone().unwrap_or_else(|| doc.first_path(component))
|
|
} else {
|
|
let placements = super::component::properties::placements(&doc, cmd)?;
|
|
if placements.iter().filter(|(owner, _, _)| *owner == component).count() != 1 {
|
|
return Err(bad(cmd, "activate the selected occurrence before extruding its faces"));
|
|
}
|
|
doc.first_path(component)
|
|
};
|
|
let placement = EmbossFace::component_frame(&doc, component, &path)?;
|
|
let placement = doc.model_body_offset(source).map(|offset| mat_mul(&placement, offset)).unwrap_or(placement);
|
|
let author_path = s.active_occurrence_path.clone().unwrap_or_else(|| doc.first_path(s.active_component));
|
|
let author = EmbossFace::component_frame(&doc, s.active_component, &author_path)?;
|
|
let inverse = mat_inverse(&author).ok_or_else(|| bad(cmd, "invalid face profile author frame"))?;
|
|
let into_author = mat_mul(&inverse, &placement);
|
|
drop(doc);
|
|
let indices: Vec<_> = picked.iter().skip(1).map(|(index, _)| *index).collect();
|
|
super::sketch_project::project_internal_faces(s, id, &body, &indices)?;
|
|
s.refresh();
|
|
let plane = s.model.state().sketch(id).map(|sketch| sketch.plane).ok_or_else(|| bad(cmd, "face profile sketch disappeared"))?;
|
|
let mut selected = vec![first_inside];
|
|
selected.extend(picked.iter().skip(1).map(|(_, point)| plane.to_local(apply_point(&into_author, *point))));
|
|
Ok((id, selected, body))
|
|
}
|
|
|
|
/// Start a sketch on the planar face at `point` holding a copy of the face boundary. Returns
|
|
/// the sketch id, a point inside the face (sketch coordinates), and the picked body's name.
|
|
/// The sketch is left active.
|
|
pub(super) fn sketch_of_face(s: &mut Session, point: Vec3, cmd: &str, face_body: Option<&str>) -> Result<(u64, Vec2, String)> {
|
|
let none = || match face_body {
|
|
Some(b) => bad(cmd, format!("no face of `{b}` at `face`")),
|
|
None => bad(cmd, "no body face at `face`"),
|
|
};
|
|
let (m, f, d, body) = face_at_in(s, point, face_body)
|
|
.map_err(|names| bad(cmd, format!("faces of several bodies meet at `face` ({}): name one with `face_body`", names.join(", "))))?
|
|
.ok_or_else(none)?;
|
|
let tol = (m.bounds().diagonal() * 1e-3).max(1e-3);
|
|
if d > tol * 10.0 {
|
|
return Err(none());
|
|
}
|
|
let tris: Vec<[Vec3; 3]> = m.triangles.iter().zip(&m.tri_face).filter(|(_, tf)| **tf == f).filter_map(|(t, _)| m.tri(t)).collect();
|
|
let normal = tris.iter().find_map(|[a, b, c]| (*b - *a).cross(*c - *a).normalized()).ok_or_else(|| bad(cmd, "degenerate face"))?;
|
|
if tris.iter().any(|[a, b, c]| (*b - *a).cross(*c - *a).normalized().is_some_and(|n| n.dot(normal) < 1.0 - 1e-6)) {
|
|
return Err(bad(cmd, "only planar faces can be extruded"));
|
|
}
|
|
// A point well inside the face: the centroid of its largest triangle.
|
|
let inside = tris
|
|
.iter()
|
|
.max_by(|x, y| (x[1] - x[0]).cross(x[2] - x[0]).len().total_cmp(&(y[1] - y[0]).cross(y[2] - y[0]).len()))
|
|
.map(|[a, b, c]| (*a + *b + *c) / 3.0)
|
|
.unwrap_or(point);
|
|
let edges: Vec<Vec<Vec3>> =
|
|
m.face_edges(f).into_iter().filter(|e| !m.seams.get(*e).copied().unwrap_or(false)).filter_map(|e| m.edges.get(e).cloned()).collect();
|
|
if edges.is_empty() || edges.len() > 5000 {
|
|
return Err(bad(cmd, "the face has no usable boundary"));
|
|
}
|
|
let run = |s: &mut Session, id: &str, p: Value| -> Result<Value> {
|
|
let spec = crate::find_command(id).ok_or_else(|| bad(cmd, id))?;
|
|
(spec.run)(s, &p)
|
|
};
|
|
// Command frame normalization already made `point` definition-local. Capture takes
|
|
// world coordinates; convert exactly once using the picked body's actual occurrence.
|
|
let state = s.model.state();
|
|
let doc = s.placed_document();
|
|
let picked = state.body(&body).ok_or_else(|| bad(cmd, "picked body disappeared"))?;
|
|
let component = doc.model_body_component(picked);
|
|
let path = if component == s.active_component {
|
|
s.active_occurrence_path.clone().unwrap_or_else(|| doc.first_path(component))
|
|
} else {
|
|
// The command mapper discarded the original placement when making this pick
|
|
// definition-local. A repeated cross-owner source cannot be re-found safely.
|
|
let placements = super::component::properties::placements(&doc, cmd)?;
|
|
if placements.iter().filter(|(owner, _, _)| *owner == component).count() != 1 {
|
|
return Err(bad(cmd, "activate the picked occurrence before generating a face profile from a repeated component"));
|
|
}
|
|
doc.first_path(component)
|
|
};
|
|
let placement = EmbossFace::component_frame(&doc, component, &path)?;
|
|
let placement = doc.model_body_offset(picked).map(|offset| mat_mul(&placement, offset)).unwrap_or(placement);
|
|
let world_inside = apply_point(&placement, inside);
|
|
let world_body = doc.world_body_name(&state, &body, component, &path);
|
|
let author_path = s.active_occurrence_path.clone().unwrap_or_else(|| doc.first_path(s.active_component));
|
|
let author = EmbossFace::component_frame(&doc, s.active_component, &author_path)?;
|
|
let author_inverse = mat_inverse(&author).ok_or_else(|| bad(cmd, "invalid face profile author frame"))?;
|
|
let author_inside = apply_point(&author_inverse, world_inside);
|
|
drop(doc);
|
|
let r = super::sketch::create_face_profile(
|
|
s,
|
|
&json!({"plane": {"face": [world_inside.x, world_inside.y, world_inside.z], "body": world_body, "index": f, "path":path}, "project_edges": true}),
|
|
&body,
|
|
f as usize,
|
|
)?;
|
|
let sid = r.get("sketch").and_then(Value::as_u64).ok_or_else(|| bad(cmd, "could not start a sketch on the face"))?;
|
|
s.refresh();
|
|
let plane = s.model.state().sketch(sid).map(|ss| ss.plane).ok_or_else(|| bad(cmd, "could not start a sketch on the face"))?;
|
|
// The face's edges came in as linked projections: they follow the face when earlier
|
|
// features change, so nothing is copied.
|
|
if r.get("projected").is_some_and(|x| !x.is_null()) {
|
|
return Ok((sid, plane.to_local(author_inside), body));
|
|
}
|
|
for e in &edges {
|
|
let pts: Vec<Vec2> = e.iter().map(|p| plane.to_local(*p)).collect();
|
|
let (Some(first), Some(last)) = (pts.first().copied(), pts.last().copied()) else { continue };
|
|
let closed = pts.len() > 3 && first.dist(last) < tol;
|
|
let circle = if pts.len() >= 4 {
|
|
let n = pts.len() - usize::from(closed);
|
|
let (a, b, c) = (pts.first(), pts.get(n / 3), pts.get(2 * n / 3));
|
|
match (a, b, c) {
|
|
(Some(a), Some(b), Some(c)) => circumcircle(*a, *b, *c).filter(|(o, r)| pts.iter().all(|q| (q.dist(*o) - r).abs() < tol)),
|
|
_ => None,
|
|
}
|
|
} else {
|
|
None
|
|
};
|
|
match circle {
|
|
Some((o, r)) if closed => run(s, "sketch.circle.center", json!({"center": xy(o), "radius": r}))?,
|
|
Some(_) => {
|
|
let mid = pts.get(pts.len() / 2).copied().unwrap_or(first);
|
|
run(s, "sketch.arc.three_point", json!({"start": xy(first), "end": xy(last), "through": xy(mid)}))?
|
|
}
|
|
None => {
|
|
let mut list: Vec<Value> = Vec::new();
|
|
for q in &pts {
|
|
// Drop points that repeat (a closed polyline ends where it starts).
|
|
if list.last().is_none_or(|l| l != &xy(*q)) {
|
|
list.push(xy(*q));
|
|
}
|
|
}
|
|
let closed_poly = list.len() > 2 && list.first() == list.last();
|
|
if closed_poly {
|
|
list.pop();
|
|
}
|
|
run(s, "sketch.line", json!({"points": list, "closed": closed_poly}))?
|
|
}
|
|
};
|
|
}
|
|
Ok((sid, plane.to_local(author_inside), body))
|
|
}
|
|
|
|
#[cfg(test)]
|
|
#[path = "face_tests.rs"]
|
|
mod tests;
|
|
|
|
#[cfg(test)]
|
|
#[path = "face_join_tests.rs"]
|
|
mod join_tests;
|