Merge ws/offset: face picks through the copy's effective identity, and solidcore errors no longer read as no answer

This commit is contained in:
Brett Lawson committed 2026-10-29 01:15:26 +01:00
commit d138b169fd
8 files changed
+233 -80

No files matched your search

+13
View File
@@ -160,6 +160,19 @@ pub(crate) fn run<T>(call: &'static str, f: impl FnOnce(&mut Kernel) -> std::res
}
}
/// A call the capi checks for `SM_SUCCESS`, treating any other status as no answer: an SMLib
/// status (solidcore's [`SolidError::Upstream`](solidcore::SolidError::Upstream), or NLib's
/// [`SolidError::Nlib`](solidcore::SolidError::Nlib)) is `None`. Every other solidcore error
/// (unported code, invalid input to an adapter, a missing record...) is not a status the C++
/// path returns, so it fails the call instead of hiding as a skipped entity.
pub(crate) fn answer<T>(r: std::result::Result<T, solidcore::SolidError>) -> std::result::Result<Option<T>, solidcore::SolidError> {
match r {
Ok(v) => Ok(Some(v)),
Err(solidcore::SolidError::Upstream { .. } | solidcore::SolidError::Nlib { .. }) => Ok(None),
Err(e) => Err(e),
}
}
/// Runs `f` on the kernel and `body`, locking the kernel first.
pub(crate) fn with_body<T>(
call: &'static str,
+3 -12
View File
@@ -48,7 +48,7 @@ use solidcore::topology::face::p2 as face_p2;
use solidcore::topology::{Brep, EdgeId, EdgeuseId, FaceId, FaceuseId, VertexId, edge, vertex};
use super::boolean::copy_of;
use super::{Body, run};
use super::{Body, answer, run};
use crate::{Blend, ChamferSecond, Error, MAX_POINTS, Result};
/// The capi's statuses as SolidCraft errors: an operation's own result.
@@ -97,8 +97,8 @@ pub(super) enum Miss {
/// `smlib_pick::pick`: the entity nearest each point, each once, with the index of the point that
/// first picked it. A point picks none when the nearest is farther than `tol`, and is ambiguous
/// when the second nearest is within `tol` too and nearer than the first by at most `model_tol`.
/// An entity whose distance cannot be measured is skipped, as the capi skips a failed query
/// (solidcore's refusal of unported code is not skipped: it fails the pick).
/// An entity whose distance query returns a status other than success is skipped, as the capi
/// skips it ([`answer`]); any other solidcore error fails the pick.
pub(super) fn pick<T: Copy + PartialEq>(
all: &[T],
points: &[[f64; 3]],
@@ -137,15 +137,6 @@ pub(super) fn pick<T: Copy + PartialEq>(
Ok(Ok((picked, first)))
}
/// A query's failure the capi treats as no answer; solidcore's unported code still fails.
pub(super) fn answer<T>(r: solidcore::Result<T>) -> solidcore::Result<Option<T>> {
match r {
Ok(v) => Ok(Some(v)),
Err(e) if e.is_unported() => Err(e),
Err(_) => Ok(None),
}
}
/// `pick_edges` (`edge_distance`: `SmApiEdgeClosestPoint`).
fn pick_edges(k: &Kernel, b: &Brep, points: &[[f64; 3]], tol: f64) -> solidcore::Result<std::result::Result<(Vec<EdgeId>, Vec<usize>), Miss>> {
let all = brep_p1::edges(b, None)?;
+1 -1
View File
@@ -47,7 +47,7 @@ fn named(entity: EntityRef, domain: u64) -> ObjectRef {
/// `copy_of` (smlib_ops.cpp, smlib_imprint.cpp): `SmApiBrepCopy`, a copy that owns its geometry.
/// A plain `Clone` is not one: its geometry keeps the source's owners. Copy `n` (from 1) names
/// its objects in key domain `n`.
pub(super) fn copy_of(k: &mut Kernel, b: &Brep, n: u64) -> SolidResult<Brep> {
pub(crate) fn copy_of(k: &mut Kernel, b: &Brep, n: u64) -> SolidResult<Brep> {
let target = move |e| named(e, n.saturating_mul(100_000_000));
let mut state = p2::ArenaNotifyState::new(&Brep::new());
let mut env = state.env(None);
+89 -35
View File
@@ -55,7 +55,7 @@ use crate::flat::*;
use crate::import::Arrays;
use crate::{Error, Result};
use super::{Body, run, with_body};
use super::{Body, answer, run, with_body};
// ---- shared ------------------------------------------------------------------------------------
@@ -415,18 +415,34 @@ fn edge_curve_as_bspline<'c>(k: &Kernel, c: &'c Curve, ivl: &Extent1d, approx_to
/// `center + s * axis`), circle or ellipse (over `[d_min, d_max]` degrees, its NURBS parameter
/// then set to that interval with its notification, `EditParameterization`).
fn build_analytic_edge_curve(k: &Kernel, ty: i64, d_min: f64, d_max: f64, center: Point3, axis: Vec3, refd: Vec3, r1: f64, r2: f64) -> Result<Curve> {
analytic_edge_curve(k, ty, d_min, d_max, center, axis, refd, r1, r2).map_err(|(call, e)| sc(call)(e))
}
/// [`build_analytic_edge_curve`] with solidcore's own error, and the call that gave it.
#[allow(clippy::too_many_arguments)] // BuildAnalyticEdgeCurve's
fn analytic_edge_curve(
k: &Kernel,
ty: i64,
d_min: f64,
d_max: f64,
center: Point3,
axis: Vec3,
refd: Vec3,
r1: f64,
r2: f64,
) -> std::result::Result<Curve, (&'static str, SolidError)> {
if ty == CURVE_LINE_I {
return Ok(Curve::from(Line::create_canonical(center, axis)));
}
let mut placement = Axis2Placement::default();
placement.set_canonical(center, refd, axis.cross(refd)).map_err(sc("SmAxis2Placement::SetCanonical"))?;
placement.set_canonical(center, refd, axis.cross(refd)).map_err(|e| ("SmAxis2Placement::SetCanonical", e))?;
let degrees = Extent1d::from_min_max(d_min, d_max);
let mut e = if ty == CURVE_CIRCLE_I {
Ellipse::create_canonical_circle(k, &placement, r1, Some(&degrees), None).map_err(sc("SmCircle::CreateCanonical"))?
Ellipse::create_canonical_circle(k, &placement, r1, Some(&degrees), None).map_err(|e| ("SmCircle::CreateCanonical", e))?
} else {
Ellipse::create_canonical(k, &placement, r1, r2, Some(&degrees), None).map_err(sc("SmEllipse::CreateCanonical"))?
Ellipse::create_canonical(k, &placement, r1, r2, Some(&degrees), None).map_err(|e| ("SmEllipse::CreateCanonical", e))?
};
e.edit_parameterization(k, &degrees, true, None).map_err(sc("SmEllipse::EditParameterization"))?;
e.edit_parameterization(k, &degrees, true, None).map_err(|e| ("SmEllipse::EditParameterization", e))?;
Ok(Curve::from(e))
}
@@ -466,12 +482,15 @@ const NURBS_EXPORT: EdgeExport = EdgeExport {
/// `ClassifyEdgeCurve`: a circle, ellipse or line kept as its kind when the curve the import
/// builds from it ([`build_analytic_edge_curve`]) matches it pointwise at the edge's ends and
/// along the STEP parameter; anything else NURBS. A curve whose STEP parameter runs against its
/// NURBS one goes with its axis reversed and its range negated.
fn classify_edge_curve(k: &Kernel, c: Option<&Curve>, ivl: &Extent1d) -> EdgeExport {
c.and_then(|c| classify(k, c, ivl)).unwrap_or(NURBS_EXPORT)
/// NURBS one goes with its axis reversed and its range negated. A call that returns a status
/// other than success makes the edge NURBS, as there ([`answer`]); any other solidcore error
/// fails the export.
fn classify_edge_curve(k: &Kernel, c: Option<&Curve>, ivl: &Extent1d) -> Result<EdgeExport> {
let Some(c) = c else { return Ok(NURBS_EXPORT) };
Ok(classify(k, c, ivl).map_err(sc("ClassifyEdgeCurve"))?.unwrap_or(NURBS_EXPORT))
}
fn classify(k: &Kernel, c: &Curve, ivl: &Extent1d) -> Option<EdgeExport> {
fn classify(k: &Kernel, c: &Curve, ivl: &Extent1d) -> std::result::Result<Option<EdgeExport>, SolidError> {
let mut e = NURBS_EXPORT;
match c.kind() {
CurveKind::Ellipse(el) => {
@@ -489,12 +508,18 @@ fn classify(k: &Kernel, c: &Curve, ivl: &Extent1d) -> Option<EdgeExport> {
e.center = can.point;
e.axis = can.vector;
}
_ => return None,
_ => return Ok(None),
}
let mut s0 = c.convert_t_from_nurbs_to_step(k, ivl.min()).ok()?;
let mut s1 = c.convert_t_from_nurbs_to_step(k, ivl.max()).ok()?;
let mut s0 = {
let Some(x) = answer(c.convert_t_from_nurbs_to_step(k, ivl.min()))? else { return Ok(None) };
x
};
let mut s1 = {
let Some(x) = answer(c.convert_t_from_nurbs_to_step(k, ivl.max()))? else { return Ok(None) };
x
};
if !s0.is_finite() || !s1.is_finite() {
return None;
return Ok(None);
}
// sNew = sign * sOld + shift
let (mut sign, mut shift) = (1.0, 0.0);
@@ -505,18 +530,18 @@ fn classify(k: &Kernel, c: &Curve, ivl: &Extent1d) -> Option<EdgeExport> {
e.axis = Vec3::new(-e.axis.x, -e.axis.y, -e.axis.z);
}
if !(s1 > s0) {
return None;
return Ok(None);
}
if e.ty == CURVE_LINE_I {
if s0.abs() > INFINITE_PARAMETER || s1.abs() > INFINITE_PARAMETER {
return None;
return Ok(None);
}
(e.lo, e.sm_lo, e.hi, e.sm_hi) = (s0, s0, s1, s1);
} else {
// SmCircle/SmEllipse::CreateCanonical take intervals within [-360, 360] degrees. (Not
// in the C++: angles past a million degrees are refused, bounding the loops below.)
if s1 - s0 > 360.0 + 1e-9 || s0.abs() > 1.0e6 || s1.abs() > 1.0e6 {
return None;
return Ok(None);
}
while s1 > 360.0 + 1e-9 {
s0 -= 360.0;
@@ -529,7 +554,7 @@ fn classify(k: &Kernel, c: &Curve, ivl: &Extent1d) -> Option<EdgeExport> {
shift += 360.0;
}
if s1 > 360.0 + 1e-9 {
return None;
return Ok(None);
}
e.lo = deg2rad(s0);
e.hi = deg2rad(s1);
@@ -538,9 +563,20 @@ fn classify(k: &Kernel, c: &Curve, ivl: &Extent1d) -> Option<EdgeExport> {
e.sm_hi = radians_to_smlib_degrees(e.hi);
}
let built = build_analytic_edge_curve(k, e.ty, e.sm_lo, e.sm_hi, e.center, e.axis, e.refd, e.r1, e.r2).ok()?;
let a = c.evaluate_point(k, ivl.min()).ok()?;
let b = c.evaluate_point(k, ivl.max()).ok()?;
let built = {
let Some(x) = answer(analytic_edge_curve(k, e.ty, e.sm_lo, e.sm_hi, e.center, e.axis, e.refd, e.r1, e.r2).map_err(|(_, e)| e))? else {
return Ok(None);
};
x
};
let a = {
let Some(x) = answer(c.evaluate_point(k, ivl.min()))? else { return Ok(None) };
x
};
let b = {
let Some(x) = answer(c.evaluate_point(k, ivl.max()))? else { return Ok(None) };
x
};
let tol = 1e-9 * (1.0 + e.r1 + e.r2 + a.max_dimension() + b.max_dimension());
let mut affine = true;
for step in 0..=8 {
@@ -548,24 +584,42 @@ fn classify(k: &Kernel, c: &Curve, ivl: &Extent1d) -> Option<EdgeExport> {
// the same point by the STEP parameter of each curve
let s_new = e.sm_lo + f * (e.sm_hi - e.sm_lo);
let s_old = (s_new - shift) * sign;
let t_old = c.convert_t_from_step_to_nurbs(k, s_old).ok()?;
let t_new = built.convert_t_from_step_to_nurbs(k, s_new).ok()?;
let p_old = c.evaluate_point(k, t_old).ok()?;
let p_new = built.evaluate_point(k, t_new).ok()?;
let t_old = {
let Some(x) = answer(c.convert_t_from_step_to_nurbs(k, s_old))? else { return Ok(None) };
x
};
let t_new = {
let Some(x) = answer(built.convert_t_from_step_to_nurbs(k, s_new))? else { return Ok(None) };
x
};
let p_old = {
let Some(x) = answer(c.evaluate_point(k, t_old))? else { return Ok(None) };
x
};
let p_new = {
let Some(x) = answer(built.evaluate_point(k, t_new))? else { return Ok(None) };
x
};
if !(p_old.distance(p_new) <= tol) {
return None;
return Ok(None);
}
// the same point by each edge's NURBS parameter, affinely matched
let q_old = c.evaluate_point(k, ivl.min() + f * (ivl.max() - ivl.min())).ok()?;
let q_new = built.evaluate_point(k, e.sm_lo + f * (e.sm_hi - e.sm_lo)).ok()?;
let q_old = {
let Some(x) = answer(c.evaluate_point(k, ivl.min() + f * (ivl.max() - ivl.min())))? else { return Ok(None) };
x
};
let q_new = {
let Some(x) = answer(built.evaluate_point(k, e.sm_lo + f * (e.sm_hi - e.sm_lo)))? else { return Ok(None) };
x
};
let d = q_old.distance(q_new);
if (step == 0 || step == 8) && !(d <= tol) {
return None; // the ends must match exactly as the edge's vertices do
return Ok(None); // the ends must match exactly as the edge's vertices do
}
affine = affine && d <= tol;
}
e.affine = affine;
Some(e)
Ok(Some(e))
}
/// `WriteEdgeCurve`: one edge's kind, range and geometry. A circle or ellipse also goes with its
@@ -752,7 +806,7 @@ fn flat_from_brep(k: &mut Kernel, b: &mut Brep) -> Result<Arrays> {
let edge_curve = |i: usize| -> Result<Option<&Curve>> { edge::curve(b, get(&edge_ids, i)?).map_err(sc("SmEdge::GetCurve")) };
let mut exports = Vec::with_capacity(bd.edges.len());
for (i, ed) in bd.edges.iter().enumerate() {
exports.push(classify_edge_curve(k, edge_curve(i)?, &ed.interval));
exports.push(classify_edge_curve(k, edge_curve(i)?, &ed.interval)?);
}
// Regions
@@ -826,9 +880,9 @@ fn flat_from_brep(k: &mut Kernel, b: &mut Brep) -> Result<Arrays> {
let mut q = [Point2::new(0.0, 0.0); 3];
let mut ok = true;
for (qk, at) in q.iter_mut().zip([Point2::new(0.0, 0.0), Point2::new(1.0, 0.0), Point2::new(0.0, 1.0)]) {
match surface.convert_uv_from_nurbs_to_step(k, at) {
Ok(st) => *qk = Point2::new(st.x * scale.x, st.y * scale.y),
Err(_) => {
match answer(surface.convert_uv_from_nurbs_to_step(k, at)).map_err(sc("SmSurface::ConvertUVFromNURBSToSTEP"))? {
Some(st) => *qk = Point2::new(st.x * scale.x, st.y * scale.y),
None => {
ok = false;
break;
}
@@ -1879,9 +1933,9 @@ fn same_nurbs(a: &NurbSurface, b: &NurbSurface, tol: f64) -> bool {
/// only when its NURBS is `nurbs` (the face's trims are in its parameters).
fn analytic_of_nurbs(k: &Kernel, nurbs: &BSplineSurface, ty: i64, tol: f64) -> Result<Option<Surface>> {
let found: Option<Surface> = if ty == SURFACE_CONE_I {
Cone::is_nurb_surface_cone(k, nurbs, 1.0).ok().flatten().map(Surface::from)
answer(Cone::is_nurb_surface_cone(k, nurbs, 1.0)).map_err(sc("SmCone::IsNurbSurfaceCone"))?.flatten().map(Surface::from)
} else if ty == SURFACE_SPHERE_I {
Sphere::is_nurb_surface_sphere(k, nurbs, 1.0).ok().flatten().map(Surface::from)
answer(Sphere::is_nurb_surface_sphere(k, nurbs, 1.0)).map_err(sc("SmSphere::IsNurbSurfaceSphere"))?.flatten().map(Surface::from)
} else if ty == SURFACE_CYLINDER_I {
return Err(unported("SmCylinder::IsNurbSurfaceCylinder"));
} else if ty == SURFACE_TORUS_I {
+15 -9
View File
@@ -28,7 +28,7 @@ use solidcore::offset::offset_executive::p2::{
OffsetNotifications, OffsetOptions, ShellCopyIdentities, ShellOptions, api_offset_brep_full, api_shell_brep_full,
};
use solidcore::query::api_queries::{BrepRef, face_bounding_box, face_classify_uv, face_closest_point_in_shape, face_internal_point};
use solidcore::query::brep::{BrepIdentity, LiveBrepObjects};
use solidcore::query::brep::{BrepIdentity, BrepQuery, LiveBrepObjects};
use solidcore::surface::surface::SurfaceKind;
use solidcore::sweep::topology_sweep::store::SweepIdentities;
use solidcore::topology::brep::{p1 as brep_p1, p2 as brep_p2, p3 as brep_p3};
@@ -36,8 +36,8 @@ use solidcore::topology::face::p2 as face_p2;
use solidcore::topology::topology::{NotifyRecords, Topology};
use solidcore::topology::{Brep, BrepId, EdgeId, FaceId, FaceuseId, RegionId};
use super::Body;
use super::blend::{Miss, answer, on_copy, p3, pick, points_ok, status as blend_status, tolerance_ok};
use super::blend::{Miss, on_copy, p3, pick, points_ok, status as blend_status, tolerance_ok};
use super::{Body, answer};
use crate::{Error, Result};
/// The capi's statuses as SolidCraft errors: an operation's own result.
@@ -116,13 +116,17 @@ impl FaceSet {
}
}
/// The live view of `b` the closest-point solves read.
fn live<'a>(b: &'a mut Brep, identity: &'a BrepIdentity<'static>) -> solidcore::Result<LiveBrepObjects<'a, 'static>> {
/// The live view of `b` the closest-point solves read, under `identity`: `query`'s effective
/// identity ([`BrepQuery::effective_identity`]). A working copy (`copy_of`) has no naming
/// scheme of its own, so `BrepIdentity::of_brep` gives it the arena's identities, which name
/// none of its geometry owners (`copy_of`'s keys, recorded on the copy as proven owners): every
/// face and edge then drops out of a solve (solidcore#1440 was this).
fn live<'a, 'i>(b: &'a mut Brep, identity: &'a BrepIdentity<'i>) -> solidcore::Result<LiveBrepObjects<'a, 'i>> {
LiveBrepObjects::new(b, identity, None)
}
/// `pick_faces` (`face_distance`: `SmApiFaceClosestPoint`; a face whose distance cannot be
/// measured is skipped).
/// `pick_faces` (`face_distance`: `SmApiFaceClosestPoint`; a face whose query returns a status
/// other than success is skipped, [`answer`]).
pub(super) fn pick_faces(k: &mut Kernel, b: &mut Brep, points: &[[f64; 3]], tol: f64) -> solidcore::Result<std::result::Result<Vec<FaceId>, Miss>> {
let all = brep_p1::faces(b, None)?;
let model_tol = b.tolerance();
@@ -130,7 +134,8 @@ pub(super) fn pick_faces(k: &mut Kernel, b: &mut Brep, points: &[[f64; 3]], tol:
for &f in &all {
shapes.push(answer(Shape::new(k, &(ONE, &*b), &[], &[(ONE, f)], &[], &[]))?);
}
let identity = BrepIdentity::of_brep(b);
let query = BrepQuery::of_brep(b);
let identity = query.effective_identity();
let objects = live(b, &identity)?;
let k: &Kernel = k;
let indices: Vec<usize> = (0..all.len()).collect();
@@ -214,7 +219,8 @@ fn leaves_cavity(k: &mut Kernel, b: &mut Brep, open: &[FaceId], wall: f64) -> so
}
}
}
let identity = BrepIdentity::of_brep(b);
let query = BrepQuery::of_brep(b);
let identity = query.effective_identity();
let objects = live(b, &identity)?;
let k: &Kernel = k;
// A step of `h` inward from a sample ends at a ball's centre when no face is nearer to it
+104 -13
View File
@@ -376,26 +376,26 @@ macro_rules! cases {
}
cases!(
shell_box_open_top: ignore = "solidcore#1440: the topology point solve misses faces, so SmApiFaceClosestPoint picks no face (solidcore#1440)",
shell_box_closed: ignore = "solidcore#1440: the topology point solve misses faces, so leaves_cavity finds no cavity (solidcore#1440)",
shell_box_open_top,
shell_box_closed,
shell_box_closed_outward,
shell_box_outward: ignore = "solidcore#1440: the topology point solve misses faces, so SmApiFaceClosestPoint picks no face (solidcore#1440)",
shell_cylinder_open_top: ignore = "solidcore#1440: the topology point solve misses faces, so SmApiFaceClosestPoint picks no face (solidcore#1440)",
shell_too_thick: ignore = "solidcore#1440: the topology point solve misses faces, so SmApiFaceClosestPoint picks no face (solidcore#1440)",
shell_walls_touch: ignore = "solidcore#1440: no face pick (solidcore#1440); walls that meet are 1027, not WALLS_TOUCH until fork a759622 is ported (solidcore#1442)",
shell_pick_near_nothing: ignore = "solidcore#1440: the topology point solve misses faces, so SmApiFaceClosestPoint picks no face (solidcore#1440)",
shell_pick_ambiguous: ignore = "solidcore#1440: the topology point solve misses faces, so SmApiFaceClosestPoint picks no face (solidcore#1440)",
shell_box_outward,
shell_cylinder_open_top: ignore = "the shell leaves the inner rim circle split at a vertex 1e-5 off it and the inner floor circle a spline (7 edges, 5 vertices; C++ 6, 4): the volume is 3.5e-7 off; cause not yet found",
shell_too_thick,
shell_walls_touch: ignore = "walls that meet are 1027, not WALLS_TOUCH until fork a759622 is ported (solidcore#1442)",
shell_pick_near_nothing,
shell_pick_ambiguous,
thicken_plate,
thicken_plate_symmetric,
thicken_a_solid,
offset_sheet_plate,
offset_sheet_quarter_cylinder: ignore = "solidcore#1441: an offset surface does not export, no SmSurface::ApproximateSurface (solidcore#1441)",
offset_sheet_a_solid,
offset_faces_top_out: ignore = "solidcore#1440: no face pick (solidcore#1440); no SmOffsetFacesExecutive, fork a96ce9f (solidcore#1060)",
offset_faces_through: ignore = "solidcore#1440: the topology point solve misses faces, so SmApiFaceClosestPoint picks no face (solidcore#1440)",
draft_box_sides: ignore = "solidcore#1440: no face pick (solidcore#1440); no SmBrep::LocalOperation (solidcore PR #1427)",
draft_a_curved_face: ignore = "solidcore#1440: the topology point solve misses faces, so SmApiFaceClosestPoint picks no face (solidcore#1440)",
draft_a_face_across_the_pull: ignore = "solidcore#1440: the topology point solve misses faces, so SmApiFaceClosestPoint picks no face (solidcore#1440)",
offset_faces_top_out: ignore = "no SmOffsetFacesExecutive, fork a96ce9f (solidcore#1060)",
offset_faces_through,
draft_box_sides: ignore = "no SmBrep::LocalOperation (solidcore PR #1427)",
draft_a_curved_face,
draft_a_face_across_the_pull,
);
/// The capi's argument checks, before any kernel call.
@@ -429,3 +429,94 @@ fn the_body_stays_as_it_was() {
assert_eq!(r.0, [6, 12, 8]);
assert!(rel(r.1, ABC) < 1e-12, "{}", r.1);
}
/// The distance from `p` to each face of `b` (`SmApiFaceClosestPoint`), under `identity`.
fn face_distances(
k: &mut solidcore::kernel::Kernel,
b: &mut solidcore::topology::Brep,
identity: &solidcore::query::brep::BrepIdentity<'_>,
p: Vec3,
) -> solidcore::Result<Vec<(f64, Vec3)>> {
use solidcore::geom::object::Shape as Sh;
use solidcore::query::api_queries::face_closest_point_in_shape;
use solidcore::query::brep::LiveBrepObjects;
use solidcore::topology::BrepId;
let one = BrepId::from_index(0);
let mut out = Vec::new();
for f in solidcore::topology::brep::p1::faces(b, None)? {
let shape = Sh::new(k, &(one, &*b), &[], &[(one, f)], &[], &[])?;
let objects = LiveBrepObjects::new(b, identity, None)?;
let c = face_closest_point_in_shape(k, &shape, &objects, (one, f), p)?;
out.push((c.distance, c.point));
}
Ok(out)
}
/// The closed form for (15, 10, 20) above the 30 x 20 x 10 box at the origin, face by face of
/// `create_box`: bottom 20, top 10, the x sides sqrt(15^2 + 10^2), the y sides sqrt(10^2 + 10^2).
fn box_face_distances_are_exact(what: &str, d: &[(f64, Vec3)]) {
let want = [20.0, 10.0, 325f64.sqrt(), 325f64.sqrt(), 200f64.sqrt(), 200f64.sqrt()];
assert_eq!(d.len(), want.len(), "{what}: faces");
for (i, (&(got, _), want)) in d.iter().zip(want).enumerate() {
assert!((got - want).abs() < 1e-9, "{what}: face {i} at {got}, want {want}");
}
let top = d[1].1;
assert!((top.x - 15.0).abs() < 1e-9 && (top.y - 10.0).abs() < 1e-9 && (top.z - 10.0).abs() < 1e-9, "{what}: top {top:?}");
}
/// Picking faces on a solidcore box: on the body itself, on the working copy every operation
/// makes (`copy_of`), and by solidcore's recommended usage, each face's distance is the closed
/// form and the top face is picked. The copy names its geometry owners in its own key domain
/// with no naming scheme of its own, so the body's identities (`BrepIdentity::of_brep`: the
/// arena's) name none of them; the copy's proven owners (`BrepQuery::effective_identity`) do
/// (solidcore#1440 was this). Under the arena's identities the solve fails, and the failure is
/// an error, not a skipped face.
#[test]
fn faces_are_picked_on_the_box_and_on_its_working_copy() {
use solidcore::SolidError;
use solidcore::query::brep::{BrepIdentity, BrepQuery};
let p = Vec3::new(15.0, 10.0, 20.0);
let on_top = [[15.0, 10.0, 10.0]];
run("pick", |k| {
let mut b = solidcore::primitive::api_primitives::create_box(k, Vec3::new(0.0, 0.0, 0.0), 30.0, 20.0, 10.0)?;
let mut w = super::boolean::copy_of(k, &b, 1)?;
let mut faces = Vec::new();
for (what, x) in [("the body", &mut b), ("its copy", &mut w)] {
let query = BrepQuery::of_brep(x);
let identity = query.effective_identity();
box_face_distances_are_exact(what, &face_distances(k, x, &identity, p)?);
let picked = super::offset::pick_faces(k, x, &on_top, TOL)?;
faces.push(picked.ok());
}
assert!(faces[0].as_ref().is_some_and(|f| f.len() == 1), "the body: {faces:?}");
assert_eq!(faces[0], faces[1], "the body and its copy pick the same face");
// The maintainers' usage: the body itself, keyed by its naming scheme.
let body = BrepIdentity::of_brep(&b);
box_face_distances_are_exact("of_brep on the body", &face_distances(k, &mut b, &body, p)?);
// The copy under the arena's identities: no face's geometry owner resolves.
let arena = BrepIdentity::of_brep(&w);
match face_distances(k, &mut w, &arena, p) {
Err(SolidError::InvalidInput { .. }) => {}
other => panic!("the copy under the arena's identities: {other:?}"),
}
Ok(())
})
.unwrap();
}
/// A pick skips an entity whose query returns an SMLib status, as the capi skips any status
/// other than `SM_SUCCESS`; any other solidcore error fails the pick.
#[test]
fn a_solidcore_error_in_a_pick_is_an_error() {
use super::answer;
use super::blend::pick;
use solidcore::SolidError;
let all = [0usize, 1];
let points = [[0.0; 3]];
let status = pick(&all, &points, 1.0, 1e-6, |i, _| answer(if i == 0 { Err(SolidError::sm_err("q")) } else { Ok(0.5) }));
assert_eq!(status.unwrap().unwrap().0, vec![1], "a status skips the entity");
let other = pick(&all, &points, 1.0, 1e-6, |i, _| answer(if i == 0 { Err(SolidError::invalid_input("q", "owner")) } else { Ok(0.5) }));
assert!(matches!(other, Err(SolidError::InvalidInput { .. })), "{other:?}");
let unported = pick(&all, &points, 1.0, 1e-6, |i, _| answer(if i == 0 { Err(SolidError::unported("Sm::X", "u")) } else { Ok(0.5) }));
assert!(matches!(unported, Err(SolidError::Unported { .. })), "{unported:?}");
}
+8 -8
View File
@@ -61,7 +61,7 @@ use solidcore::topology::{Brep, FaceId};
use super::blend::status;
use super::offset::{face_miss, pick_faces};
use super::{Body, run, with_body};
use super::{Body, answer, run, with_body};
use crate::sweeps::{Affine, Curve as Profile, DraftCorner, Ends, MAX_CURVES, MAX_STATION_CURVES, MAX_STATIONS, SweepFrame};
use crate::{Error, Result, ffi};
@@ -304,12 +304,12 @@ fn tangent(k: &Kernel, c: &Curve, t: f64, from_left: bool) -> solidcore::Result<
}
/// Whether the angle about `n` from `a` to `b` is a sharp corner (`sm_DraftHasCorner`: more than
/// `SM_EFF_ZERO_SQRT`); an angle that cannot be measured is none, as there.
fn sharp(n: Vec3, a: Option<Vec3>, b: Option<Vec3>) -> bool {
match (a, b) {
(Some(a), Some(b)) => n.ccw_angle_between(a, b).is_ok_and(|x| x.abs() > EFF_ZERO_SQRT),
/// `SM_EFF_ZERO_SQRT`); an angle whose measure returns a status is none, as there ([`answer`]).
fn sharp(n: Vec3, a: Option<Vec3>, b: Option<Vec3>) -> solidcore::Result<bool> {
Ok(match (a, b) {
(Some(a), Some(b)) => answer(n.ccw_angle_between(a, b))?.is_some_and(|x| x.abs() > EFF_ZERO_SQRT),
_ => false,
}
})
}
/// `sm_DraftHasCorner`, on the profile as given (one closed loop, in order): whether it has a
@@ -320,14 +320,14 @@ fn has_corner(k: &Kernel, curves: &[Curve], n: Vec3) -> solidcore::Result<bool>
for (i, b) in curves.iter().enumerate() {
let Some(a) = curves.get((i + count - 1) % count) else { continue };
let (ia, ib) = (a.natural_interval(), b.natural_interval());
if sharp(n, tangent(k, a, ia.max(), true)?, tangent(k, b, ib.min(), false)?) {
if sharp(n, tangent(k, a, ia.max(), true)?, tangent(k, b, ib.min(), false)?)? {
return Ok(true);
}
if let CurveKind::BSpline(s) = b.kind() {
let c = s.canonical()?;
let inner = c.knots.iter().zip(&c.knot_multiplicities).skip(1).take(c.knots.len().saturating_sub(2));
for (&u, &m) in inner {
if m >= c.degree && sharp(n, tangent(k, b, u, true)?, tangent(k, b, u, false)?) {
if m >= c.degree && sharp(n, tangent(k, b, u, true)?, tangent(k, b, u, false)?)? {
return Ok(true);
}
}
-2
View File
@@ -464,7 +464,6 @@ fn the_cpp_kernel_places_the_profile_alike() {
/// A diagonal 10 above a 10 x 10 x 10 box's top, projected down onto the top: the same diagonal
/// at z = 10.
#[test]
#[ignore = "solidcore#1440: the topology point solve misses faces, so SmApiFaceClosestPoint picks no face (solidcore#1440)"]
fn project_a_line_onto_a_face() {
let got = timed("project", || {
let b = make_box([0.0; 3], [10.0; 3]).unwrap();
@@ -482,7 +481,6 @@ fn project_a_line_onto_a_face() {
/// A face's planar section needs `SmBrep::CreatePlanarSectionCurves`: not supported, after the
/// face pick.
#[test]
#[ignore = "solidcore#1440: the topology point solve misses faces, so the face pick fails first (solidcore#1440); then no CreatePlanarSectionCurves (solidcore#1451)"]
fn a_face_section_is_not_supported_yet() {
let got = timed("section", || {
let b = make_box([0.0; 3], [10.0; 3]).unwrap();