Validation::EachStep checks every solid sweep, boolean and blend result in SMLib as before; EachFeature leaves those checks to the end of the feature and says a check was left; Off skips them. The evaluation installs the mode around a feature (validating), as watch installs a watch; outside it every step is checked as always, and the kernel's worker threads run under the caller's mode. Under EachFeature a body decoded from a step keeps that step's SMLib result (for its own record only), and check_kept checks it as the step's own check would have, then lets it go; any other kept body is checked as SMLib imports its record. The record can pass where the result fails: a fillet's surface of revolution whose polar curve SMLib's check refuses (fillets/1080-fillet-sloped-basin-1-mm-rim-r0-5-4-edges) is rebuilt on import, and its round meets a wall at 72 degrees; checking the record alone kept that round. The largest-size search of a blend checks every candidate as it is built, whatever the mode: a candidate fits only as a body the check accepts. Surface operations and stitching keep their checks. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
262 lines
12 KiB
Rust
262 lines
12 KiB
Rust
//! How often SMLib's full check runs while a model is evaluated. Every sweep, boolean and blend
|
|
//! checks its result in SMLib before it is decoded ([`Validation::EachStep`]); an evaluation can
|
|
//! instead leave those checks to one check of the bodies each feature keeps
|
|
//! ([`Validation::EachFeature`]), or skip them ([`Validation::Off`]). A body kept straight from
|
|
//! a step is checked at the end as that step would have checked it, on the step's own result
|
|
//! (kept with the body until then): the record a result is decoded to can pass SMLib's check
|
|
//! where the result itself fails it (a surface of revolution's polar curve, rebuilt on import).
|
|
//!
|
|
//! The evaluation installs its mode around a feature with [`validating`], as [`crate::watch`]
|
|
//! installs a watch: the operations a feature runs are reached through hundreds of public kernel
|
|
//! functions, and the mode is the evaluation's, not each operation's. Outside [`validating`]
|
|
//! (the kernel called directly, a preview, a test) every step is checked, as it always was. The
|
|
//! worker threads the kernel starts for a step run under the same mode ([`crate::par`]).
|
|
|
|
use std::cell::RefCell;
|
|
use std::sync::Arc;
|
|
use std::sync::atomic::{AtomicBool, Ordering};
|
|
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
use crate::body::Body;
|
|
use crate::{KernelError, Result};
|
|
|
|
/// When SMLib's full check of a result runs during a model evaluation.
|
|
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
|
|
#[serde(rename_all = "snake_case")]
|
|
pub enum Validation {
|
|
/// After every sweep, boolean and blend: a step whose result fails the check fails the
|
|
/// feature there (how every evaluation checked before the mode existed).
|
|
EachStep,
|
|
/// Once per feature: the steps inside a feature are not checked, and each body the feature
|
|
/// makes or changes is checked before it is kept, so a feature that makes a body the check
|
|
/// refuses still fails, with the check's reason.
|
|
#[default]
|
|
EachFeature,
|
|
/// Never (experimental): a body the check would refuse is kept.
|
|
Off,
|
|
}
|
|
|
|
impl Validation {
|
|
pub const ALL: [Validation; 3] = [Validation::EachStep, Validation::EachFeature, Validation::Off];
|
|
|
|
/// The mode's name: `each_step`, `each_feature` or `off` (as it is saved and sent).
|
|
pub fn id(self) -> &'static str {
|
|
match self {
|
|
Validation::EachStep => "each_step",
|
|
Validation::EachFeature => "each_feature",
|
|
Validation::Off => "off",
|
|
}
|
|
}
|
|
|
|
/// The mode named `id` ([`Validation::id`]), `None` for anything else.
|
|
pub fn parse(id: &str) -> Option<Validation> {
|
|
Validation::ALL.into_iter().find(|v| v.id() == id)
|
|
}
|
|
}
|
|
|
|
/// One feature's work under a mode, shared with the worker threads it starts.
|
|
#[derive(Debug)]
|
|
pub(crate) struct Scope {
|
|
mode: Validation,
|
|
/// A step's check was left for the end of the feature ([`Validation::EachFeature`]).
|
|
deferred: AtomicBool,
|
|
}
|
|
|
|
thread_local! {
|
|
static CURRENT: RefCell<Option<Arc<Scope>>> = const { RefCell::new(None) };
|
|
}
|
|
|
|
/// Run `f` with `mode` deciding which checks the kernel work it does on this thread runs. Also
|
|
/// gives whether a step's check was left for later under [`Validation::EachFeature`]: the
|
|
/// caller then checks the bodies it keeps ([`check_kept`]).
|
|
pub fn validating<R>(mode: Validation, f: impl FnOnce() -> R) -> (R, bool) {
|
|
let scope = Arc::new(Scope { mode, deferred: AtomicBool::new(false) });
|
|
let r = within(Some(scope.clone()), f);
|
|
(r, scope.deferred.load(Ordering::Relaxed))
|
|
}
|
|
|
|
/// The scope this thread's work runs in, to hand to the worker threads it starts.
|
|
pub(crate) fn current() -> Option<Arc<Scope>> {
|
|
CURRENT.with(|c| c.borrow().clone())
|
|
}
|
|
|
|
/// Run `f` in `scope` (one [`current`] gave on another thread), restoring this thread's own
|
|
/// afterwards, also when `f` panics.
|
|
pub(crate) fn within<R>(scope: Option<Arc<Scope>>, f: impl FnOnce() -> R) -> R {
|
|
struct Restore(Option<Option<Arc<Scope>>>);
|
|
impl Drop for Restore {
|
|
fn drop(&mut self) {
|
|
if let Some(previous) = self.0.take() {
|
|
CURRENT.with(|c| *c.borrow_mut() = previous);
|
|
}
|
|
}
|
|
}
|
|
let previous = CURRENT.with(|c| c.replace(scope));
|
|
let _restore = Restore(Some(previous));
|
|
f()
|
|
}
|
|
|
|
/// What a step does with SMLib's check of its result ([`step`]).
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
|
pub(crate) enum Step {
|
|
/// Check it now (outside [`validating`], and under [`Validation::EachStep`]).
|
|
Check,
|
|
/// Leave it to the end of the feature (under [`Validation::EachFeature`]): the body decoded
|
|
/// from the result keeps it ([`Body::left_unchecked`]) for [`check_kept`].
|
|
Defer,
|
|
/// Never check it (under [`Validation::Off`]).
|
|
Skip,
|
|
}
|
|
|
|
/// What the step about to check its result does. [`Step::Defer`] also tells the feature a check
|
|
/// was left for its end.
|
|
pub(crate) fn step() -> Step {
|
|
CURRENT.with(|c| match c.borrow().as_deref() {
|
|
None | Some(Scope { mode: Validation::EachStep, .. }) => Step::Check,
|
|
Some(s @ Scope { mode: Validation::EachFeature, .. }) => {
|
|
s.deferred.store(true, Ordering::Relaxed);
|
|
Step::Defer
|
|
}
|
|
Some(Scope { mode: Validation::Off, .. }) => Step::Skip,
|
|
})
|
|
}
|
|
|
|
/// How a step's own check takes its result.
|
|
#[derive(Clone, Copy, Debug)]
|
|
pub(crate) enum Checked {
|
|
/// As it is.
|
|
AsIs,
|
|
/// A boolean's: solids touching each other along an edge or at a vertex come back as one
|
|
/// non-manifold body, checked as the separate solids its export holds (the boolean's rule).
|
|
Combined,
|
|
}
|
|
|
|
/// A step's SMLib result whose check was left to the end of its feature: kept with the body
|
|
/// decoded from it (and only for that body's record) until [`check_kept`] takes it, so the check
|
|
/// at the end is the step's own, of the result the step made.
|
|
#[derive(Debug)]
|
|
pub(crate) struct Unchecked {
|
|
record: std::sync::Weak<solidcraft_geom::brep::Brep>,
|
|
/// The step, as its own refusal names it (`SMLib fillet`).
|
|
what: String,
|
|
how: Checked,
|
|
result: std::sync::Mutex<Option<solidcraft_smlib::Brep>>,
|
|
}
|
|
|
|
impl Unchecked {
|
|
pub(crate) fn new(record: &Arc<solidcraft_geom::brep::Brep>, what: &str, how: Checked, result: solidcraft_smlib::Brep) -> Unchecked {
|
|
Unchecked { record: Arc::downgrade(record), what: what.to_string(), how, result: std::sync::Mutex::new(Some(result)) }
|
|
}
|
|
|
|
/// The step's result, taken (once), when this is `record`'s.
|
|
fn take(&self, record: &Arc<solidcraft_geom::brep::Brep>) -> Option<solidcraft_smlib::Brep> {
|
|
if !std::ptr::eq(self.record.as_ptr(), Arc::as_ptr(record)) {
|
|
return None;
|
|
}
|
|
self.result.lock().ok().and_then(|mut r| r.take())
|
|
}
|
|
}
|
|
|
|
/// SMLib's full check of `r` as a step takes it (`how`): the check's report.
|
|
pub(crate) fn check_result(r: &solidcraft_smlib::Brep, how: Checked) -> std::result::Result<solidcraft_smlib::CheckReport, String> {
|
|
fn failed(what: &'static str) -> impl Fn(&dyn std::fmt::Display) -> String {
|
|
move |e| format!("{what}: {e}")
|
|
}
|
|
match how {
|
|
Checked::Combined if !r.is_manifold_solid().map_err(|e| failed("check")(&e))? => {
|
|
let record = r.to_native().map_err(|e| failed("export")(&e))?;
|
|
let split = solidcraft_smlib::Brep::from_record(&record, true).map_err(|e| failed("the separate solids")(&e))?;
|
|
split.check(solidcraft_smlib::CheckLevel::All).map_err(|e| failed("check")(&e))
|
|
}
|
|
_ => r.check(solidcraft_smlib::CheckLevel::All).map_err(|e| failed("check")(&e)),
|
|
}
|
|
}
|
|
|
|
/// SMLib's full check of a body a feature keeps, once a step of the feature left its check to
|
|
/// the end: an error with the check's reason unless it passes. A body decoded from a step's
|
|
/// result is checked as that step would have checked it, on its result; any other (a copy moved
|
|
/// into place, pieces joined without an operation) as SMLib takes it for the operations after it.
|
|
/// A mesh body has nothing to check.
|
|
pub fn check_kept(body: &Body) -> Result<()> {
|
|
if body.is_mesh() {
|
|
return Ok(());
|
|
}
|
|
let step = body.unchecked.as_deref().and_then(|u| u.take(&body.record).map(|r| (u, r)));
|
|
let (what, check) = match &step {
|
|
Some((u, r)) => (u.what.as_str(), check_result(r, u.how)),
|
|
None => ("SMLib", body.smlib()?.check(solidcraft_smlib::CheckLevel::All).map_err(|e| format!("check: {e}"))),
|
|
};
|
|
match check {
|
|
Ok(c) if c.is_valid() => Ok(()),
|
|
Ok(c) => Err(KernelError::Failed(format!("{what}: SMLib's check refuses the result: {c}"))),
|
|
Err(e) => Err(KernelError::Failed(format!("{what}: {e}"))),
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn a_step_is_checked_outside_an_evaluation_and_under_each_step() {
|
|
assert_eq!(step(), Step::Check);
|
|
assert_eq!(validating(Validation::EachStep, step), (Step::Check, false));
|
|
assert_eq!(validating(Validation::EachFeature, step), (Step::Defer, true));
|
|
assert_eq!(validating(Validation::Off, step), (Step::Skip, false));
|
|
// The thread's own mode comes back, also after a nested scope.
|
|
let ((inner, outer), deferred) = validating(Validation::Off, || (validating(Validation::EachStep, step).0, step()));
|
|
assert!(inner == Step::Check && outer == Step::Skip && !deferred);
|
|
assert_eq!(step(), Step::Check);
|
|
}
|
|
|
|
#[test]
|
|
fn the_mode_reaches_the_kernels_worker_threads() {
|
|
let items = [0, 1, 2, 3];
|
|
let (checked, deferred) = validating(Validation::EachFeature, || {
|
|
crate::par::map("validation", &items, true, |_| Ok(step())).into_iter().collect::<Result<Vec<Step>>>()
|
|
});
|
|
assert_eq!(checked.ok(), Some(vec![Step::Defer; 4]));
|
|
assert!(deferred);
|
|
let (on_threads, deferred) = validating(Validation::EachFeature, || crate::par::map_on_threads(&items, 4, |_| step()));
|
|
assert_eq!(on_threads, vec![Some(Step::Defer); 4]);
|
|
assert!(deferred);
|
|
}
|
|
|
|
/// A box with one corner moved off its three edges: SMLib's check refuses it. Under each_step
|
|
/// the boolean that takes it refuses its result there; under each_feature it is not checked,
|
|
/// says the check was left for later, and the check of the body kept refuses it.
|
|
#[cfg(feature = "smlib")]
|
|
#[test]
|
|
fn a_body_the_check_refuses_is_refused_at_the_step_or_at_the_end() {
|
|
use solidcraft_geom::Vec3;
|
|
let good = crate::box_solid(Vec3::new(0.0, 0.0, 0.0), Vec3::new(10.0, 10.0, 10.0)).unwrap();
|
|
assert!(check_kept(&good).is_ok());
|
|
let mut record = good.record().clone();
|
|
record.vertices[0].point[2] += 0.5;
|
|
let bad = Body::from_record(record).unwrap();
|
|
let e = check_kept(&bad).unwrap_err().to_string();
|
|
assert!(e.contains("SMLib's check refuses the result"), "{e}");
|
|
let tool = crate::box_solid(Vec3::new(5.0, 5.0, 5.0), Vec3::new(20.0, 20.0, 20.0)).unwrap();
|
|
let (step, deferred) = validating(Validation::EachStep, || crate::boolean(&bad, &tool, crate::BoolOp::Union));
|
|
let e = step.unwrap_err().to_string();
|
|
assert!(e.contains("SMLib's check refuses the result (the first operand already fails it)") && !deferred, "{e}");
|
|
let (joined, deferred) = validating(Validation::EachFeature, || crate::boolean(&bad, &tool, crate::BoolOp::Union));
|
|
assert!(deferred);
|
|
let joined = joined.unwrap().unwrap();
|
|
assert!(check_kept(&joined).unwrap_err().to_string().contains("SMLib's check refuses the result"));
|
|
let (off, deferred) = validating(Validation::Off, || crate::boolean(&bad, &tool, crate::BoolOp::Union));
|
|
assert!(off.is_ok_and(|b| b.is_some()) && !deferred);
|
|
}
|
|
|
|
#[test]
|
|
fn modes_are_named_as_they_are_saved() {
|
|
for v in Validation::ALL {
|
|
assert_eq!(Validation::parse(v.id()), Some(v));
|
|
assert_eq!(serde_json::to_value(v).ok(), Some(serde_json::json!(v.id())));
|
|
}
|
|
assert_eq!(Validation::parse("each step"), None);
|
|
assert_eq!(Validation::default(), Validation::EachFeature);
|
|
}
|
|
}
|