Kernel rig: export each case's kernel operations as a corpus for solidcore's rig
`cargo xtask kernel-cases [--ladder] --export DIR` runs the rig with the kernel's operations traced (`smlib::trace`) and writes one entry per case: the operation, or chain of operations, that made the bodies the case ends with; each operand that came in as a record, as that record; the parameters, with every pick by points also given as the topology index it picked; the fix set; the case's expected values and the rig's result. A case no kernel operation alone accounts for is written too, marked not expressible with its reasons. DIR/manifest.json counts them per area. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ
This commit is contained in:
@@ -657,7 +657,34 @@ fn flat_pattern_checks(c: &mut Checks, want: &Value, results: &[Value], rel: f64
|
||||
}
|
||||
}
|
||||
|
||||
fn check_case(dir: &str, dumps: Option<&std::path::Path>, validation: solidcraft_engine::kernel::Validation) -> Value {
|
||||
/// [`check_case_in`], and with `export` the case's corpus entry written under it
|
||||
/// ([`crate::kernel_cases_export`]).
|
||||
fn check_case(
|
||||
dir: &str,
|
||||
dumps: Option<&std::path::Path>,
|
||||
validation: solidcraft_engine::kernel::Validation,
|
||||
export: Option<&std::path::Path>,
|
||||
) -> Value {
|
||||
let mut capture = export.map(|_| crate::kernel_cases_export::Capture::default());
|
||||
let out = check_case_in(dir, dumps, validation, capture.as_mut());
|
||||
if let (Some(root), Some(capture)) = (export, capture)
|
||||
&& let Err(e) = crate::kernel_cases_export::write(root, dir, &out, capture)
|
||||
{
|
||||
let mut out = out;
|
||||
out["export_error"] = json!(e);
|
||||
return out;
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// One case run and graded. With `capture`, the kernel operations its commands make are traced
|
||||
/// and kept there with the bodies the case ends with.
|
||||
fn check_case_in(
|
||||
dir: &str,
|
||||
dumps: Option<&std::path::Path>,
|
||||
validation: solidcraft_engine::kernel::Validation,
|
||||
mut capture: Option<&mut crate::kernel_cases_export::Capture>,
|
||||
) -> Value {
|
||||
let (area, name) = case_name(dir);
|
||||
let mut out = json!({"case": name, "area": area, "kernel": kernel()});
|
||||
let want = match read_json(&format!("{dir}/expected.json")) {
|
||||
@@ -711,7 +738,14 @@ fn check_case(dir: &str, dumps: Option<&std::path::Path>, validation: solidcraft
|
||||
let mut s = solidcraft_engine::Session::default();
|
||||
s.set_validation(validation);
|
||||
let clock = std::time::Instant::now();
|
||||
if capture.is_some() {
|
||||
solidcraft_engine::kernel::smlib_trace::start();
|
||||
}
|
||||
let ran = s.run_script(&commands);
|
||||
// The trace ends with the commands: grading reads the bodies through the kernel too.
|
||||
if let Some(c) = capture.as_deref_mut() {
|
||||
c.events = solidcraft_engine::kernel::smlib_trace::finish();
|
||||
}
|
||||
// The commands' own time, without process start or grading: the ladder's timing golden.
|
||||
out["seconds"] = json!(clock.elapsed().as_secs_f64());
|
||||
let answers = match (ran, may_refuse) {
|
||||
@@ -762,6 +796,9 @@ fn check_case(dir: &str, dumps: Option<&std::path::Path>, validation: solidcraft
|
||||
return out;
|
||||
}
|
||||
};
|
||||
if let Some(c) = capture.as_deref_mut() {
|
||||
c.world = world.bodies.iter().map(|b| (b.name.clone(), b.body.record().clone())).collect();
|
||||
}
|
||||
let mut bodies = Vec::new();
|
||||
let mut c = Checks { list: Vec::new(), pass: true };
|
||||
let want_valid = want["valid"].as_bool().unwrap_or(true);
|
||||
@@ -976,7 +1013,13 @@ pub fn run(args: &[String]) -> Result<(), String> {
|
||||
.ok_or_else(|| format!("kernel-cases: --validation= must be each_step, each_feature or off, not `{m}`"))?,
|
||||
None => solidcraft_engine::kernel::Validation::default(),
|
||||
};
|
||||
let results: Vec<Value> = dirs.iter().map(|d| check_case(d, dumps.as_deref(), validation)).collect();
|
||||
// `--export=DIR`: each case's kernel operations, their input records and its expected values
|
||||
// go to DIR/<area>/<case>.json, the corpus for solidcore's rig.
|
||||
let export = args.iter().find_map(|a| a.strip_prefix("--export=")).map(std::path::PathBuf::from);
|
||||
if export.as_ref().is_some_and(|d| d.as_os_str().is_empty()) {
|
||||
return Err("kernel-cases: --export= needs a folder".into());
|
||||
}
|
||||
let results: Vec<Value> = dirs.iter().map(|d| check_case(d, dumps.as_deref(), validation, export.as_deref())).collect();
|
||||
if dumps.is_some() {
|
||||
solidcraft_engine::kernel::smlib_dump_dir(None);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,279 @@
|
||||
//! `kernel-cases --export=DIR`: one kernel rig case as a corpus entry for solidcore's rig. The
|
||||
//! case's commands run as the rig runs them while the kernel's operations are traced
|
||||
//! (`smlib_trace`); the entry holds the operation (or the chain of operations) that made the
|
||||
//! bodies the case ends with, each operand that came in as a record given as that record (the
|
||||
//! B-rep record, solidcore-record's JSON), the fix set, the case's expected values and the rig's
|
||||
//! own result. A case whose result no kernel operation alone accounts for is written too, marked
|
||||
//! not expressible with the reasons, so nothing is dropped silently.
|
||||
//!
|
||||
//! An entry is expressible when:
|
||||
//! - the run failed in a kernel operation (the engine's error carries the operation's), or every
|
||||
//! body the case ends with is the record a traced operation's output was written as, or an
|
||||
//! operand some traced operation took, as its record;
|
||||
//! - its expected values are all the kernel's measures: none of `continuity`, `watertight`,
|
||||
//! `files`, `results`, `construction` or `flat_pattern`, which SolidCraft computes;
|
||||
//! - the counts it grades (faces, edges, vertices) are the records' own: the rig counts faces and
|
||||
//! edges merged across one analytic surface or curve (`merged_topology`, from a mesh), so an
|
||||
//! entry where those differ is not expressible.
|
||||
|
||||
use std::collections::{BTreeMap, BTreeSet, HashMap};
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use serde_json::{Value, json};
|
||||
use solidcraft_engine::geom::brep::Brep;
|
||||
use solidcraft_engine::kernel::smlib_trace::{self, Event};
|
||||
|
||||
use crate::read_json;
|
||||
|
||||
/// What a traced case leaves for its entry: the trace of its commands and the bodies it ends with.
|
||||
#[derive(Default)]
|
||||
pub struct Capture {
|
||||
pub events: Vec<Event>,
|
||||
pub world: Vec<(String, Brep)>,
|
||||
}
|
||||
|
||||
/// The expected values SolidCraft computes, never the kernel.
|
||||
const GRADER_ONLY: [&str; 6] = ["continuity", "watertight", "files", "results", "construction", "flat_pattern"];
|
||||
|
||||
/// The case directory's area (its path under `tests/kernel-cases/`, a ladder case's tier under
|
||||
/// `ladder/`) and its id.
|
||||
fn area_and_id(dir: &str) -> Result<(String, String), String> {
|
||||
let p = Path::new(dir);
|
||||
let parts: Vec<String> = p.components().map(|c| c.as_os_str().to_string_lossy().to_string()).collect();
|
||||
let at = parts.iter().rposition(|c| c == "kernel-cases").ok_or_else(|| format!("{dir}: not under tests/kernel-cases"))?;
|
||||
let rest = parts.get(at + 1..).unwrap_or_default();
|
||||
match rest.split_last() {
|
||||
Some((id, area)) if !area.is_empty() => Ok((area.join("/"), id.clone())),
|
||||
_ => Err(format!("{dir}: no area")),
|
||||
}
|
||||
}
|
||||
|
||||
/// The case's line in its area's `KNOWN_FAILING`: why it fails today; `None` when not listed.
|
||||
fn known_failing(dir: &str, id: &str) -> Option<String> {
|
||||
let list = Path::new(dir).parent()?.join("KNOWN_FAILING");
|
||||
let text = std::fs::read_to_string(list).ok()?;
|
||||
text.lines().filter(|l| !l.trim_start().starts_with('#')).find_map(|l| {
|
||||
let (case, why) = l.split_once(char::is_whitespace).unwrap_or((l, ""));
|
||||
(case == id).then(|| why.trim().to_string())
|
||||
})
|
||||
}
|
||||
|
||||
/// The trace read as operations and the records that went in and came out.
|
||||
struct Trace<'a> {
|
||||
/// Each operation: its name, operands, parameters and outputs or error.
|
||||
calls: Vec<(&'static str, &'a [u64], &'a Value, &'a Result<Vec<u64>, String>)>,
|
||||
/// The record each body made from a record was made from.
|
||||
imports: HashMap<u64, (&'a Brep, bool, bool)>,
|
||||
/// The records bodies were written as, in order.
|
||||
exports: Vec<(u64, &'a Brep)>,
|
||||
/// The operation that made each body.
|
||||
producer: HashMap<u64, usize>,
|
||||
}
|
||||
|
||||
impl<'a> Trace<'a> {
|
||||
fn of(events: &'a [Event]) -> Trace<'a> {
|
||||
let mut t = Trace { calls: Vec::new(), imports: HashMap::new(), exports: Vec::new(), producer: HashMap::new() };
|
||||
for e in events {
|
||||
match e {
|
||||
Event::Import { id, record, trusted, keeping_splines } => {
|
||||
t.imports.insert(*id, (record, *trusted, *keeping_splines));
|
||||
}
|
||||
Event::Export { id, record } => t.exports.push((*id, record)),
|
||||
Event::Call { op, inputs, params, outputs } => {
|
||||
if let Ok(made) = outputs {
|
||||
for id in made {
|
||||
t.producer.insert(*id, t.calls.len());
|
||||
}
|
||||
}
|
||||
t.calls.push((*op, inputs, params, outputs));
|
||||
}
|
||||
}
|
||||
}
|
||||
t
|
||||
}
|
||||
|
||||
/// Bodies some operation took as an operand.
|
||||
fn operands(&self) -> BTreeSet<u64> {
|
||||
self.calls.iter().flat_map(|c| c.1.iter().copied()).collect()
|
||||
}
|
||||
}
|
||||
|
||||
/// The operations `ends` need, in the order they ran: each body's maker, and its operands' makers
|
||||
/// in turn, back to bodies made from records. Operands made by nothing traced are listed in
|
||||
/// `unknown`.
|
||||
fn chain(t: &Trace<'_>, ends: &[u64], unknown: &mut BTreeSet<u64>) -> Vec<usize> {
|
||||
let mut need = BTreeSet::new();
|
||||
let mut todo: Vec<u64> = ends.to_vec();
|
||||
while let Some(id) = todo.pop() {
|
||||
if t.imports.contains_key(&id) {
|
||||
continue;
|
||||
}
|
||||
match t.producer.get(&id) {
|
||||
Some(&i) => {
|
||||
if need.insert(i)
|
||||
&& let Some(c) = t.calls.get(i)
|
||||
{
|
||||
todo.extend(c.1.iter().copied());
|
||||
}
|
||||
}
|
||||
None => {
|
||||
unknown.insert(id);
|
||||
}
|
||||
}
|
||||
}
|
||||
need.into_iter().collect()
|
||||
}
|
||||
|
||||
/// The entry of case `dir`, run with result `out`, into `root/<area>/<id>.json`, and the fix set
|
||||
/// into `root/fixes.json`.
|
||||
pub fn write(root: &Path, dir: &str, out: &Value, capture: Capture) -> Result<(), String> {
|
||||
let (area, id) = area_and_id(dir)?;
|
||||
let want = read_json(&format!("{dir}/expected.json"))?;
|
||||
let t = Trace::of(&capture.events);
|
||||
let mut why_not: Vec<String> = Vec::new();
|
||||
let status = out["status"].as_str().unwrap_or("");
|
||||
|
||||
if let Some(missing) = want["missing"].as_str() {
|
||||
why_not.push(format!("SolidCraft has no command for it yet: {missing}"));
|
||||
}
|
||||
let grader: Vec<&str> = GRADER_ONLY.iter().copied().filter(|k| want.get(*k).is_some_and(|v| !v.is_null())).collect();
|
||||
if !grader.is_empty() {
|
||||
why_not.push(format!("graded on what SolidCraft computes: {}", grader.join(", ")));
|
||||
}
|
||||
|
||||
// The bodies the entry ends with: what each is, by name.
|
||||
let mut result: Vec<Value> = Vec::new();
|
||||
let mut ends: Vec<u64> = Vec::new();
|
||||
let mut failed_call: Option<usize> = None;
|
||||
let error = out["refused_with"].as_str().or_else(|| out["error"].as_str()).filter(|_| out.get("checks").is_none());
|
||||
if let Some(e) = error.filter(|_| want.get("missing").is_none()) {
|
||||
// The run stopped: the kernel operation that failed with the message the engine gave.
|
||||
failed_call = t.calls.iter().rposition(|c| matches!(c.3, Err(m) if !m.is_empty() && e.contains(m.as_str())));
|
||||
match failed_call {
|
||||
Some(i) => ends.extend(t.calls.get(i).map(|c| c.1.to_vec()).unwrap_or_default()),
|
||||
None if t.calls.is_empty() => why_not.push(format!("no kernel operation ran before the failure: {e}")),
|
||||
None => why_not.push(format!("the failure is SolidCraft's, not a kernel operation's: {e}")),
|
||||
}
|
||||
} else if want.get("missing").is_none() {
|
||||
let operands = t.operands();
|
||||
let mut made = 0;
|
||||
for (name, record) in &capture.world {
|
||||
let from_op = t.exports.iter().rev().find(|(_, r)| *r == record).map(|(id, _)| *id).filter(|id| t.producer.contains_key(id));
|
||||
let operand = t.imports.iter().find(|(i, (r, _, _))| *r == record && operands.contains(i)).map(|(i, _)| *i);
|
||||
match (from_op, operand) {
|
||||
(Some(id), _) => {
|
||||
made += 1;
|
||||
ends.push(id);
|
||||
result.push(json!({"body": name, "made": format!("b{id}")}));
|
||||
}
|
||||
(None, Some(id)) => {
|
||||
ends.push(id);
|
||||
result.push(json!({"body": name, "operand": format!("b{id}")}));
|
||||
}
|
||||
(None, None) => why_not.push(format!(
|
||||
"body {name:?} is no kernel operation's output nor an operand: SolidCraft built it or changed the kernel's record"
|
||||
)),
|
||||
}
|
||||
}
|
||||
if capture.world.is_empty() {
|
||||
why_not.push("the case ends with no body".into());
|
||||
} else if made == 0 && why_not.is_empty() {
|
||||
why_not.push("no kernel operation made a body the case ends with".into());
|
||||
}
|
||||
// Counts graded as SolidCraft merges them, where that differs from the records'.
|
||||
let raw = |k: &str| -> u64 {
|
||||
capture
|
||||
.world
|
||||
.iter()
|
||||
.map(|(_, r)| match k {
|
||||
"faces" => r.faces.len(),
|
||||
"edges" => r.edges.len(),
|
||||
_ => r.vertices.len(),
|
||||
} as u64)
|
||||
.sum()
|
||||
};
|
||||
for k in ["faces", "edges", "vertices"] {
|
||||
let graded = want.get(k).is_some_and(|v| !v.is_null());
|
||||
let merged = out["measured"][k].as_u64();
|
||||
if graded && merged.is_some_and(|m| m != raw(k)) {
|
||||
why_not.push(format!("{k} graded merged across analytic surfaces ({}), the records have {}", merged.unwrap_or(0), raw(k)));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let mut unknown = BTreeSet::new();
|
||||
let order = chain(&t, &ends, &mut unknown);
|
||||
if !unknown.is_empty() {
|
||||
why_not.push(format!("operands made by nothing traced: {unknown:?}"));
|
||||
}
|
||||
let order: Vec<usize> = match failed_call {
|
||||
Some(i) if !order.contains(&i) => order.into_iter().chain([i]).collect(),
|
||||
_ => order,
|
||||
};
|
||||
// Operand records: every body the chain takes that came in as a record.
|
||||
let mut bodies = BTreeMap::new();
|
||||
let calls: Vec<Value> = order
|
||||
.iter()
|
||||
.filter_map(|&i| t.calls.get(i))
|
||||
.map(|(op, inputs, params, outputs)| {
|
||||
for id in inputs.iter() {
|
||||
if let Some((record, trusted, splines)) = t.imports.get(id) {
|
||||
bodies.insert(format!("b{id}"), json!({"trusted": trusted, "keeping_splines": splines, "record": record}));
|
||||
}
|
||||
}
|
||||
let mut c = json!({"op": op, "inputs": inputs.iter().map(|i| format!("b{i}")).collect::<Vec<_>>(), "params": params});
|
||||
match outputs {
|
||||
Ok(made) => c["outputs"] = json!(made.iter().map(|i| format!("b{i}")).collect::<Vec<_>>()),
|
||||
Err(e) => c["error"] = json!(e),
|
||||
}
|
||||
c
|
||||
})
|
||||
.collect();
|
||||
for (_, record) in &capture.world {
|
||||
// An operand the case ends with, never operated on in the chain, still comes as its record.
|
||||
if let Some(id) = t.imports.iter().find(|(_, (r, _, _))| *r == record).map(|(i, _)| *i)
|
||||
&& result.iter().any(|r| r["operand"] == json!(format!("b{id}")))
|
||||
&& let Some((record, trusted, splines)) = t.imports.get(&id)
|
||||
{
|
||||
bodies.insert(format!("b{id}"), json!({"trusted": trusted, "keeping_splines": splines, "record": record}));
|
||||
}
|
||||
}
|
||||
let rig = json!({
|
||||
"status": out["status"], "error": out["error"], "refused_with": out["refused_with"], "measured": out["measured"],
|
||||
"known_failing": known_failing(dir, &id),
|
||||
});
|
||||
let entry = json!({
|
||||
"case": id,
|
||||
"area": area,
|
||||
"sources": want["sources"],
|
||||
"what": want["what"],
|
||||
"expressible": why_not.is_empty(),
|
||||
"why_not": why_not,
|
||||
"expected": want,
|
||||
"rig": rig,
|
||||
"calls": calls,
|
||||
"bodies": bodies,
|
||||
"result": result,
|
||||
"traced_ops": t.calls.iter().map(|c| c.0).collect::<Vec<_>>(),
|
||||
"status": status,
|
||||
});
|
||||
let folder: PathBuf = root.join(&area);
|
||||
std::fs::create_dir_all(&folder).map_err(|e| format!("{}: {e}", folder.display()))?;
|
||||
let path = folder.join(format!("{id}.json"));
|
||||
let text = serde_json::to_string(&entry).map_err(|e| e.to_string())?;
|
||||
std::fs::write(&path, text).map_err(|e| format!("{}: {e}", path.display()))?;
|
||||
let fixes = serde_json::to_string_pretty(&smlib_trace::fixes()).map_err(|e| e.to_string())?;
|
||||
std::fs::write(root.join("fixes.json"), fixes).map_err(|e| format!("{}: {e}", root.display()))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn the_area_is_the_path_under_kernel_cases() {
|
||||
assert_eq!(area_and_id("tests/kernel-cases/booleans/1894-x").unwrap(), ("booleans".into(), "1894-x".into()));
|
||||
assert_eq!(area_and_id("/r/tests/kernel-cases/ladder/07-fillets/003-y").unwrap(), ("ladder/07-fillets".into(), "003-y".into()));
|
||||
assert!(area_and_id("/r/other/x").is_err());
|
||||
}
|
||||
}
|
||||
@@ -35,6 +35,7 @@ mod bench_assistant;
|
||||
mod crashes;
|
||||
mod fuzz;
|
||||
mod kernel_cases;
|
||||
mod kernel_cases_export;
|
||||
mod logger;
|
||||
mod oracle;
|
||||
mod preview;
|
||||
@@ -85,7 +86,7 @@ const USAGE_RECIPE: &str = " solidcraft-cli recipe <recipe.json>\n";
|
||||
/// `oracle`'s lines in the usage.
|
||||
const USAGE_ORACLE: &str = " solidcraft-cli oracle <case-dir>... [--json]\n";
|
||||
/// `kernel-cases`'s lines in the usage.
|
||||
const USAGE_KERNEL_CASES: &str = " solidcraft-cli kernel-cases <case-dir>... [--json] [--dumps=DIR] [--validation=each_step|each_feature|off]\n (the kernel regression rig, tests/kernel-cases, on SMLib; --dumps: each case's\n failing SMLib calls leave their inputs for replay in DIR/<area>-<case>; --validation: when SMLib's\n full check runs (diagnostics.validation), default each_feature)\n";
|
||||
const USAGE_KERNEL_CASES: &str = " solidcraft-cli kernel-cases <case-dir>... [--json] [--dumps=DIR] [--export=DIR] [--validation=each_step|each_feature|off]\n (the kernel regression rig, tests/kernel-cases, on SMLib; --dumps: each case's\n failing SMLib calls leave their inputs for replay in DIR/<area>-<case>; --export: each case's\n kernel operations, input records and expected values for solidcore's rig, in DIR/<area>/<case>.json; --validation: when SMLib's\n full check runs (diagnostics.validation), default each_feature)\n";
|
||||
/// `fuzz`'s lines in the usage.
|
||||
const USAGE_FUZZ: &str =
|
||||
" solidcraft-cli fuzz [--from N] [--count N] [--jobs J] [--timeout S] [--steps N] [--minimise] [--out DIR] [--report FILE]\n";
|
||||
|
||||
@@ -215,6 +215,7 @@ pub use prism_curve::{PlanarPiece, PlanarSpline};
|
||||
pub use prism_measure::{PrismSection, certified_prism_equivalent, certified_prism_section};
|
||||
pub use repair::{Hole, RebuiltFace, RefusedFace, RepairOptions, RepairReport, SewnGap, repair};
|
||||
pub use sew::{EdgeSpec, FaceSpec, SurfSpec, sew, sew_touching};
|
||||
pub use solidcraft_smlib::trace as smlib_trace;
|
||||
pub use splitface::{SplitTool, split_body, split_faces, split_faces_with_map};
|
||||
pub use step::step_export;
|
||||
pub use step_in::{
|
||||
|
||||
@@ -11,6 +11,7 @@ workspace = true
|
||||
|
||||
[dependencies]
|
||||
log = { workspace = true }
|
||||
serde_json = { workspace = true }
|
||||
solidcraft-geom = { workspace = true }
|
||||
solidcraft-profile = { workspace = true }
|
||||
solidcore = { workspace = true }
|
||||
@@ -18,4 +19,3 @@ solidcore = { workspace = true }
|
||||
[dev-dependencies]
|
||||
solidcraft-profile = { workspace = true, features = ["enabled"] }
|
||||
flate2 = "1.1"
|
||||
serde_json = { workspace = true }
|
||||
|
||||
@@ -37,6 +37,7 @@ mod merge_tests;
|
||||
pub(crate) mod offset;
|
||||
#[cfg(test)]
|
||||
mod offset_tests;
|
||||
pub(crate) mod picked;
|
||||
pub(crate) mod split;
|
||||
#[cfg(test)]
|
||||
mod split_tests;
|
||||
|
||||
@@ -161,7 +161,7 @@ pub(super) fn pick_edges(
|
||||
}
|
||||
|
||||
/// `pick_vertices` (`vertex_distance`).
|
||||
fn pick_vertices(b: &Brep, points: &[[f64; 3]], tol: f64) -> solidcore::Result<std::result::Result<(Vec<VertexId>, Vec<usize>), Miss>> {
|
||||
pub(super) fn pick_vertices(b: &Brep, points: &[[f64; 3]], tol: f64) -> solidcore::Result<std::result::Result<(Vec<VertexId>, Vec<usize>), Miss>> {
|
||||
let all = brep_p1::vertices(b, None)?;
|
||||
pick(&all, points, tol, b.tolerance(), |v, p| Ok(Some((b.vertex(v)?.point - p).length())))
|
||||
}
|
||||
|
||||
@@ -97,7 +97,8 @@ plain!(
|
||||
Brep,
|
||||
solidcore::geom::vector3d::Point3,
|
||||
crate::history::Raw,
|
||||
crate::MassProperties
|
||||
crate::MassProperties,
|
||||
Vec<crate::trace::Pick>
|
||||
);
|
||||
|
||||
impl<T> Answer for Option<T> {}
|
||||
|
||||
@@ -0,0 +1,80 @@
|
||||
//! What a pick by points chose, as indices into the body's own lists: for the operations a trace
|
||||
//! records ([`crate::trace`]), so the corpus names its edges, faces and corners by topology
|
||||
//! index as well as by the points the operation was given. Each point is picked alone, by the
|
||||
//! same picker the operation runs, on the body as the operation received it.
|
||||
|
||||
use std::sync::PoisonError;
|
||||
|
||||
use solidcore::topology::brep::p1 as brep_p1;
|
||||
use solidcore::topology::{edge, vertex};
|
||||
|
||||
use super::Body;
|
||||
use super::blend::{Miss, pick_edges, pick_vertices};
|
||||
use super::offset::pick_faces;
|
||||
use crate::Result;
|
||||
use crate::trace::{Pick, PickKind};
|
||||
|
||||
/// The entity each of `points` picks within `tolerance` on `body`, as [`Pick`]s: its index in
|
||||
/// the body's list of that kind (`None` where the point picks none or is ambiguous) and, for an
|
||||
/// edge, its end points; for a vertex, its point.
|
||||
pub(crate) fn picks(body: &Body, kind: PickKind, points: &[[f64; 3]], tolerance: f64) -> Result<Vec<Pick>> {
|
||||
super::run_on("trace pick", &[], |k| {
|
||||
let mut b = body.0.lock().unwrap_or_else(PoisonError::into_inner);
|
||||
let mut out = Vec::with_capacity(points.len());
|
||||
for p in points {
|
||||
let one = std::slice::from_ref(p);
|
||||
let pick = match kind {
|
||||
PickKind::Edge => {
|
||||
let all = brep_p1::edges(&b, None)?;
|
||||
match pick_edges(k, &b, one, tolerance)? {
|
||||
Ok((es, _)) => match es.first() {
|
||||
Some(&e) => {
|
||||
let mut ends = Vec::with_capacity(2);
|
||||
for v in [edge::start_vertex(&b, e)?, edge::end_vertex(&b, e)?].into_iter().flatten() {
|
||||
let q = vertex::point(&b, v)?;
|
||||
ends.push([q.x, q.y, q.z]);
|
||||
}
|
||||
Pick { index: all.iter().position(|&x| x == e), at: ends, miss: None }
|
||||
}
|
||||
None => Pick::missed("none"),
|
||||
},
|
||||
Err(m) => Pick::missed(miss(m)),
|
||||
}
|
||||
}
|
||||
PickKind::Face => {
|
||||
let all = brep_p1::faces(&b, None)?;
|
||||
match pick_faces(k, &mut b, one, tolerance)? {
|
||||
Ok(fs) => match fs.first() {
|
||||
Some(&f) => Pick { index: all.iter().position(|&x| x == f), at: Vec::new(), miss: None },
|
||||
None => Pick::missed("none"),
|
||||
},
|
||||
Err(m) => Pick::missed(miss(m)),
|
||||
}
|
||||
}
|
||||
PickKind::Vertex => {
|
||||
let all = brep_p1::vertices(&b, None)?;
|
||||
match pick_vertices(&b, one, tolerance)? {
|
||||
Ok((vs, _)) => match vs.first() {
|
||||
Some(&v) => {
|
||||
let q = vertex::point(&b, v)?;
|
||||
Pick { index: all.iter().position(|&x| x == v), at: vec![[q.x, q.y, q.z]], miss: None }
|
||||
}
|
||||
None => Pick::missed("none"),
|
||||
},
|
||||
Err(m) => Pick::missed(miss(m)),
|
||||
}
|
||||
}
|
||||
};
|
||||
out.push(pick);
|
||||
}
|
||||
b.refresh_cached_topology();
|
||||
Ok(out)
|
||||
})
|
||||
}
|
||||
|
||||
fn miss(m: Miss) -> &'static str {
|
||||
match m {
|
||||
Miss::None(_) => "none",
|
||||
Miss::Ambiguous(_) => "ambiguous",
|
||||
}
|
||||
}
|
||||
@@ -50,23 +50,41 @@ use crate::{Brep, Result};
|
||||
impl Brep {
|
||||
/// A cylinder about +Z: base centre, radius and height (mm, > 0).
|
||||
pub fn make_cylinder(origin: [f64; 3], radius: f64, height: f64) -> Result<Brep> {
|
||||
crate::core::make_cylinder(origin, radius, height).map(Brep::made_core)
|
||||
let r = crate::core::make_cylinder(origin, radius, height).map(Brep::made_core);
|
||||
crate::trace::made("make_cylinder", &[], &r, || serde_json::json!({"origin": origin, "radius": radius, "height": height}));
|
||||
r
|
||||
}
|
||||
|
||||
/// A sphere: centre and radius (mm, > 0).
|
||||
pub fn make_sphere(center: [f64; 3], radius: f64) -> Result<Brep> {
|
||||
crate::core::make_sphere(center, radius).map(Brep::made_core)
|
||||
let r = crate::core::make_sphere(center, radius).map(Brep::made_core);
|
||||
crate::trace::made("make_sphere", &[], &r, || serde_json::json!({"center": center, "radius": radius}));
|
||||
r
|
||||
}
|
||||
|
||||
/// A cone or frustum about +Z: base centre, base radius (> 0), top radius (≥ 0, not the base
|
||||
/// radius) and height (> 0), in mm.
|
||||
pub fn make_cone(origin: [f64; 3], base_radius: f64, top_radius: f64, height: f64) -> Result<Brep> {
|
||||
crate::core::make_cone(origin, base_radius, top_radius, height).map(Brep::made_core)
|
||||
let r = crate::core::make_cone(origin, base_radius, top_radius, height).map(Brep::made_core);
|
||||
crate::trace::made(
|
||||
"make_cone",
|
||||
&[],
|
||||
&r,
|
||||
|| serde_json::json!({"origin": origin, "base_radius": base_radius, "top_radius": top_radius, "height": height}),
|
||||
);
|
||||
r
|
||||
}
|
||||
|
||||
/// A ring torus about +Z: centre, major radius > minor radius > 0 (mm).
|
||||
pub fn make_torus(center: [f64; 3], major_radius: f64, minor_radius: f64) -> Result<Brep> {
|
||||
crate::core::make_torus(center, major_radius, minor_radius).map(Brep::made_core)
|
||||
let r = crate::core::make_torus(center, major_radius, minor_radius).map(Brep::made_core);
|
||||
crate::trace::made(
|
||||
"make_torus",
|
||||
&[],
|
||||
&r,
|
||||
|| serde_json::json!({"center": center, "major_radius": major_radius, "minor_radius": minor_radius}),
|
||||
);
|
||||
r
|
||||
}
|
||||
|
||||
/// The flat arrays of this body that the mapping reads.
|
||||
@@ -82,7 +100,11 @@ impl Brep {
|
||||
/// [`Brep::to_native`], with what the mapping kept as SMLib wrote it.
|
||||
pub fn to_native_report(&self) -> std::result::Result<(b::Brep, Report), ExportError> {
|
||||
let arrays = self.arrays().map_err(ExportError::Smlib)?;
|
||||
native(&arrays)
|
||||
let r = native(&arrays);
|
||||
if let Ok((record, _)) = &r {
|
||||
crate::trace::exported(self, record);
|
||||
}
|
||||
r
|
||||
}
|
||||
|
||||
/// [`Brep::to_native`], with where each of SMLib's faces and edges went in the record's
|
||||
@@ -91,7 +113,11 @@ impl Brep {
|
||||
/// `GetEdges`), the order its history uses.
|
||||
pub fn to_native_ordered(&self) -> std::result::Result<(b::Brep, Order), ExportError> {
|
||||
let arrays = self.arrays().map_err(ExportError::Smlib)?;
|
||||
native_ordered(&arrays).map(|(brep, _, order)| (brep, order))
|
||||
let r = native_ordered(&arrays).map(|(brep, _, order)| (brep, order));
|
||||
if let Ok((record, _)) = &r {
|
||||
crate::trace::exported(self, record);
|
||||
}
|
||||
r
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -68,7 +68,9 @@ impl Brep {
|
||||
/// SMLib's order, which the copy keeps). Run an operation on tagged copies, then read its
|
||||
/// result's [`Brep::history`].
|
||||
pub fn tagged(&self, operand: usize) -> Result<Brep> {
|
||||
core::history::tag(self.core(), operand).map(Brep::made_core)
|
||||
let r = core::history::tag(self.core(), operand).map(Brep::made_core);
|
||||
crate::trace::made("tagged", &[self], &r, || serde_json::json!({"operand": operand}));
|
||||
r
|
||||
}
|
||||
|
||||
/// The history of this body, made by an operation from tagged operands: each face's and
|
||||
|
||||
@@ -673,13 +673,15 @@ impl crate::Brep {
|
||||
|
||||
/// The SMLib B-rep of a schema 4 record. `trusted` as in [`arrays`].
|
||||
pub fn from_record(brep: &b::Brep, trusted: bool) -> crate::Result<crate::Brep> {
|
||||
let a = arrays(brep, trusted).map_err(crate::Error::Record)?;
|
||||
crate::Brep::from_arrays(&a)
|
||||
let r = arrays(brep, trusted).map_err(crate::Error::Record).and_then(|a| crate::Brep::from_arrays(&a));
|
||||
crate::trace::imported(&r, brep, trusted, false);
|
||||
r
|
||||
}
|
||||
|
||||
/// [`crate::Brep::from_record`] through [`arrays_keeping_splines`].
|
||||
pub fn from_record_keeping_splines(brep: &b::Brep, trusted: bool) -> crate::Result<crate::Brep> {
|
||||
let a = arrays_keeping_splines(brep, trusted).map_err(crate::Error::Record)?;
|
||||
crate::Brep::from_arrays(&a)
|
||||
let r = arrays_keeping_splines(brep, trusted).map_err(crate::Error::Record).and_then(|a| crate::Brep::from_arrays(&a));
|
||||
crate::trace::imported(&r, brep, trusted, true);
|
||||
r
|
||||
}
|
||||
}
|
||||
|
||||
+13
-4
@@ -20,6 +20,7 @@ mod sheets;
|
||||
mod split;
|
||||
pub mod ssi;
|
||||
pub mod sweeps;
|
||||
pub mod trace;
|
||||
pub mod trim;
|
||||
|
||||
pub use check::{CheckLevel, CheckReport};
|
||||
@@ -250,6 +251,8 @@ pub fn crash_test() -> Result<()> {
|
||||
/// A B-rep. Immutable: operations return new bodies.
|
||||
pub struct Brep {
|
||||
body: core::Body,
|
||||
/// The body's number in a trace ([`trace`]).
|
||||
id: u64,
|
||||
}
|
||||
|
||||
impl std::fmt::Debug for Brep {
|
||||
@@ -261,7 +264,7 @@ impl std::fmt::Debug for Brep {
|
||||
impl Brep {
|
||||
/// A body solidcore made.
|
||||
fn made_core(body: core::Body) -> Brep {
|
||||
Brep { body }
|
||||
Brep { body, id: trace::next_id() }
|
||||
}
|
||||
|
||||
/// solidcore's body.
|
||||
@@ -271,7 +274,9 @@ impl Brep {
|
||||
|
||||
/// An axis-aligned box from its lower corner, with positive edge lengths (mm).
|
||||
pub fn make_box(origin: [f64; 3], size: [f64; 3]) -> Result<Brep> {
|
||||
core::make_box(origin, size).map(Brep::made_core)
|
||||
let r = core::make_box(origin, size).map(Brep::made_core);
|
||||
trace::made("make_box", &[], &r, || serde_json::json!({"origin": origin, "size": size}));
|
||||
r
|
||||
}
|
||||
|
||||
/// Reads a native SMLib `.smb` file.
|
||||
@@ -286,7 +291,9 @@ impl Brep {
|
||||
|
||||
/// A deep copy.
|
||||
pub fn try_clone(&self) -> Result<Brep> {
|
||||
core::transform::copy(self.core()).map(Brep::made_core)
|
||||
let r = core::transform::copy(self.core()).map(Brep::made_core);
|
||||
trace::made("copy", &[self], &r, || serde_json::json!({}));
|
||||
r
|
||||
}
|
||||
|
||||
/// This body moved by the affine `matrix` (column-major: columns 0–2 the images of x, y and
|
||||
@@ -294,7 +301,9 @@ impl Brep {
|
||||
/// mirror it, a non-uniform scale or a shear turns its geometry into NURBS, tolerances scale
|
||||
/// with it.
|
||||
pub fn transformed(&self, matrix: &[[f64; 4]; 4]) -> Result<Brep> {
|
||||
core::transform::transform(self.core(), matrix).map(Brep::made_core)
|
||||
let r = core::transform::transform(self.core(), matrix).map(Brep::made_core);
|
||||
trace::made("transform", &[self], &r, || serde_json::json!({"matrix": matrix}));
|
||||
r
|
||||
}
|
||||
|
||||
/// The enclosed volume (mm³) at `relative_accuracy` (SMLib clamps it to [1e-8, 1e-1]).
|
||||
|
||||
+120
-18
@@ -6,6 +6,9 @@
|
||||
//! edge (face) nearest to it, which must lie within `tolerance` of it and be nearer than any other
|
||||
//! by more than the body's modelling tolerance ([`Error::NoMatch`], [`Error::Ambiguous`]).
|
||||
|
||||
use serde_json::json;
|
||||
|
||||
use crate::trace::{self, PickKind};
|
||||
use crate::{Brep, Error, Result, core};
|
||||
|
||||
/// How [`Brep::boolean`] combines two bodies.
|
||||
@@ -17,6 +20,17 @@ pub enum BooleanOp {
|
||||
Intersect,
|
||||
}
|
||||
|
||||
impl BooleanOp {
|
||||
/// The operation's name in a trace ([`crate::trace`]).
|
||||
pub fn word(self) -> &'static str {
|
||||
match self {
|
||||
BooleanOp::Union => "union",
|
||||
BooleanOp::Subtract => "subtract",
|
||||
BooleanOp::Intersect => "intersect",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// What [`Brep::blend`] makes of each selected edge.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum Blend {
|
||||
@@ -32,6 +46,18 @@ pub enum Blend {
|
||||
Chamfer,
|
||||
}
|
||||
|
||||
impl Blend {
|
||||
/// The section's name in a trace ([`crate::trace`]).
|
||||
pub fn word(self) -> &'static str {
|
||||
match self {
|
||||
Blend::Round => "round",
|
||||
Blend::Curvature => "curvature",
|
||||
Blend::Chord => "chord",
|
||||
Blend::Chamfer => "chamfer",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The second side of [`Brep::chamfer_sides`].
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum ChamferSecond {
|
||||
@@ -69,7 +95,9 @@ impl Brep {
|
||||
/// as one body, counted by [`Brep::solid_count`]. Tagged operands ([`Brep::tagged`]) give a
|
||||
/// result whose [`Brep::history`] says where each face and edge came from.
|
||||
pub fn boolean(&self, other: &Brep, op: BooleanOp) -> Result<Option<Brep>> {
|
||||
core::boolean::boolean(self.core(), other.core(), op).map(|r| r.map(Brep::made_core))
|
||||
let r = core::boolean::boolean(self.core(), other.core(), op).map(|r| r.map(Brep::made_core));
|
||||
trace::maybe("boolean", &[self, other], &r, || json!({"op": op.word()}));
|
||||
r
|
||||
}
|
||||
|
||||
/// The union of `breps` in one call: they are unioned pairwise, level by level, so none takes
|
||||
@@ -81,21 +109,27 @@ impl Brep {
|
||||
return Err(Error::Argument);
|
||||
}
|
||||
let bodies: Vec<&core::Body> = breps.iter().map(|b| b.core()).collect();
|
||||
core::boolean::union_all(&bodies).map(Brep::made_core)
|
||||
let r = core::boolean::union_all(&bodies).map(Brep::made_core);
|
||||
trace::made("union_all", breps, &r, || json!({}));
|
||||
r
|
||||
}
|
||||
|
||||
/// `self` and `other`, sheets of planar faces on one plane ([`Brep::planar_faces`]), combined
|
||||
/// as regions of that plane by `op`: `None` when the result is empty. The result's edges are
|
||||
/// the inputs' own curves, split where they cross.
|
||||
pub fn boolean2d(&self, other: &Brep, op: BooleanOp) -> Result<Option<Brep>> {
|
||||
core::boolean::boolean2d(self.core(), other.core(), op).map(|r| r.map(Brep::made_core))
|
||||
let r = core::boolean::boolean2d(self.core(), other.core(), op).map(|r| r.map(Brep::made_core));
|
||||
trace::maybe("boolean2d", &[self, other], &r, || json!({"op": op.word()}));
|
||||
r
|
||||
}
|
||||
|
||||
/// `self` with each face `tool` meets cut along the intersection, the pieces kept as faces of
|
||||
/// one body: `None` when the tool meets no face. Tagged operands give the pieces' history
|
||||
/// (each piece is a split of the face it was cut from).
|
||||
pub fn imprint(&self, tool: &Brep) -> Result<Option<Brep>> {
|
||||
core::boolean::imprint(self.core(), tool.core()).map(|r| r.map(Brep::made_core))
|
||||
let r = core::boolean::imprint(self.core(), tool.core()).map(|r| r.map(Brep::made_core));
|
||||
trace::maybe("imprint", &[self, tool], &r, || json!({}));
|
||||
r
|
||||
}
|
||||
|
||||
/// The number of separate solid regions (voids not counted).
|
||||
@@ -106,14 +140,18 @@ impl Brep {
|
||||
/// The edges nearest to `edges` (each within `tolerance`), exactly those, rounded
|
||||
/// at `radius`.
|
||||
pub fn fillet(&self, edges: &[[f64; 3]], tolerance: f64, radius: f64) -> Result<Brep> {
|
||||
self.core_blend(Blend::Round, edges, &[radius], tolerance, &[], &[], core::blend::Corners::Filled)
|
||||
let r = self.core_blend(Blend::Round, edges, &[radius], tolerance, &[], &[], core::blend::Corners::Filled);
|
||||
trace::made("fillet", &[self], &r, || json!({"edges": trace::picks(self, PickKind::Edge, edges, tolerance), "radius": radius}));
|
||||
r
|
||||
}
|
||||
|
||||
/// The edges nearest to `edges` (each within `tolerance`), exactly those, cut by
|
||||
/// an equal-distance chamfer `distance` back along each face (measured at each edge's
|
||||
/// midpoint), with bevelled corners.
|
||||
pub fn chamfer(&self, edges: &[[f64; 3]], tolerance: f64, distance: f64) -> Result<Brep> {
|
||||
self.core_blend(Blend::Chamfer, edges, &[distance], tolerance, &[], &[], core::blend::Corners::Filled)
|
||||
let r = self.core_blend(Blend::Chamfer, edges, &[distance], tolerance, &[], &[], core::blend::Corners::Filled);
|
||||
trace::made("chamfer", &[self], &r, || json!({"edges": trace::picks(self, PickKind::Edge, edges, tolerance), "distance": distance}));
|
||||
r
|
||||
}
|
||||
|
||||
/// The edges nearest to `edges` (each within `tolerance`), exactly those, blended
|
||||
@@ -122,7 +160,14 @@ impl Brep {
|
||||
if edges.len() > MAX_POINTS || edges.is_empty() || sizes.len() != edges.len() {
|
||||
return Err(Error::Argument);
|
||||
}
|
||||
self.core_blend(kind, edges, sizes, tolerance, &[], &[], core::blend::Corners::Filled)
|
||||
let r = self.core_blend(kind, edges, sizes, tolerance, &[], &[], core::blend::Corners::Filled);
|
||||
trace::made(
|
||||
"blend",
|
||||
&[self],
|
||||
&r,
|
||||
|| json!({"kind": kind.word(), "edges": trace::picks(self, PickKind::Edge, edges, tolerance), "sizes": sizes}),
|
||||
);
|
||||
r
|
||||
}
|
||||
|
||||
/// [`Brep::blend`], with whether each point picked an edge that a larger round, overflowing
|
||||
@@ -132,7 +177,15 @@ impl Brep {
|
||||
if edges.len() > MAX_POINTS || edges.is_empty() || sizes.len() != edges.len() {
|
||||
return Err(Error::Argument);
|
||||
}
|
||||
core::blend::blend_dropping(self.core(), kind, edges, sizes, tolerance).map(|(b, d)| (Brep::made_core(b), d))
|
||||
let r = core::blend::blend_dropping(self.core(), kind, edges, sizes, tolerance).map(|(b, d)| (Brep::made_core(b), d));
|
||||
trace::call(
|
||||
"blend_dropping",
|
||||
&[self],
|
||||
&r,
|
||||
|(b, _)| vec![b.id],
|
||||
|| json!({"kind": kind.word(), "edges": trace::picks(self, PickKind::Edge, edges, tolerance), "sizes": sizes}),
|
||||
);
|
||||
r
|
||||
}
|
||||
|
||||
/// [`Brep::blend`] with corner setbacks: each of `corners` picks the vertex nearest it
|
||||
@@ -158,7 +211,12 @@ impl Brep {
|
||||
{
|
||||
return Err(Error::Argument);
|
||||
}
|
||||
self.core_blend(kind, edges, sizes, tolerance, corners, setbacks, core::blend::Corners::Filled)
|
||||
let r = self.core_blend(kind, edges, sizes, tolerance, corners, setbacks, core::blend::Corners::Filled);
|
||||
trace::made("blend_setback", &[self], &r, || {
|
||||
json!({"kind": kind.word(), "edges": trace::picks(self, PickKind::Edge, edges, tolerance), "sizes": sizes,
|
||||
"corners": trace::picks(self, PickKind::Vertex, corners, tolerance), "setbacks": setbacks})
|
||||
});
|
||||
r
|
||||
}
|
||||
|
||||
/// [`Brep::blend_setback`] with each set-back corner left open: SMLib's patch between the
|
||||
@@ -184,8 +242,19 @@ impl Brep {
|
||||
{
|
||||
return Err(Error::Argument);
|
||||
}
|
||||
core::blend::blend_holes(self.core(), kind, edges, sizes, tolerance, corners, setbacks, core::blend::Corners::Open)
|
||||
.map(|(b, holes)| (Brep::made_core(b), holes))
|
||||
let r = core::blend::blend_holes(self.core(), kind, edges, sizes, tolerance, corners, setbacks, core::blend::Corners::Open)
|
||||
.map(|(b, holes)| (Brep::made_core(b), holes));
|
||||
trace::call(
|
||||
"blend_setback_open",
|
||||
&[self],
|
||||
&r,
|
||||
|(b, _)| vec![b.id],
|
||||
|| {
|
||||
json!({"kind": kind.word(), "edges": trace::picks(self, PickKind::Edge, edges, tolerance), "sizes": sizes,
|
||||
"corners": trace::picks(self, PickKind::Vertex, corners, tolerance), "setbacks": setbacks})
|
||||
},
|
||||
);
|
||||
r
|
||||
}
|
||||
|
||||
/// The one edge nearest to `edge` (within `tolerance`) rounded with a radius
|
||||
@@ -193,7 +262,14 @@ impl Brep {
|
||||
/// `radii` over the position along the edge, 0 at its end nearest `start` and 1 at the other
|
||||
/// (the edge curve's parameter scaled to 0..1).
|
||||
pub fn fillet_variable(&self, edge: [f64; 3], tolerance: f64, start: [f64; 3], degree: usize, knots: &[f64], radii: &[f64]) -> Result<Brep> {
|
||||
core::blend::fillet_variable(self.core(), edge, tolerance, start, degree, knots, radii).map(Brep::made_core)
|
||||
let r = core::blend::fillet_variable(self.core(), edge, tolerance, start, degree, knots, radii).map(Brep::made_core);
|
||||
trace::made(
|
||||
"fillet_variable",
|
||||
&[self],
|
||||
&r,
|
||||
|| json!({"edge": trace::picks(self, PickKind::Edge, &[edge], tolerance), "start": start, "degree": degree, "knots": knots, "radii": radii}),
|
||||
);
|
||||
r
|
||||
}
|
||||
|
||||
/// The edges nearest to `edges` (each within `tolerance`), exactly those, cut by
|
||||
@@ -204,7 +280,15 @@ impl Brep {
|
||||
if edges.is_empty() || edges.len() > MAX_POINTS {
|
||||
return Err(Error::Argument);
|
||||
}
|
||||
core::blend::chamfer_sides(self.core(), edges, tolerance, distance, second, first).map(Brep::made_core)
|
||||
let r = core::blend::chamfer_sides(self.core(), edges, tolerance, distance, second, first).map(Brep::made_core);
|
||||
trace::made("chamfer_sides", &[self], &r, || {
|
||||
let second = match second {
|
||||
ChamferSecond::Distance(d) => json!({"distance": d}),
|
||||
ChamferSecond::Angle(a) => json!({"angle": a}),
|
||||
};
|
||||
json!({"edges": trace::picks(self, PickKind::Edge, edges, tolerance), "distance": distance, "second": second, "first": first})
|
||||
});
|
||||
r
|
||||
}
|
||||
|
||||
/// Hollowed to a wall of `thickness` (negative: inside the original surface, positive:
|
||||
@@ -213,7 +297,14 @@ impl Brep {
|
||||
/// whose walls would just meet (a hole exactly twice the wall from a side) is
|
||||
/// [`Error::WallsTouch`].
|
||||
pub fn shell(&self, open_faces: &[[f64; 3]], tolerance: f64, thickness: f64) -> Result<Brep> {
|
||||
core::offset::shell(self.core(), open_faces, tolerance, thickness).map(Brep::made_core)
|
||||
let r = core::offset::shell(self.core(), open_faces, tolerance, thickness).map(Brep::made_core);
|
||||
trace::made(
|
||||
"shell",
|
||||
&[self],
|
||||
&r,
|
||||
|| json!({"open_faces": trace::picks(self, PickKind::Face, open_faces, tolerance), "thickness": thickness}),
|
||||
);
|
||||
r
|
||||
}
|
||||
|
||||
/// The solid with the faces nearest to `faces` (each within `tolerance`) moved `distance`
|
||||
@@ -221,14 +312,18 @@ impl Brep {
|
||||
/// faces around them extended or trimmed to meet them. Faces moved in past all of the body
|
||||
/// behind them are [`Error::NoRoom`].
|
||||
pub fn offset_faces(&self, faces: &[[f64; 3]], tolerance: f64, distance: f64) -> Result<Brep> {
|
||||
core::offset::offset_faces(self.core(), faces, tolerance, distance).map(Brep::made_core)
|
||||
let r = core::offset::offset_faces(self.core(), faces, tolerance, distance).map(Brep::made_core);
|
||||
trace::made("offset_faces", &[self], &r, || json!({"faces": trace::picks(self, PickKind::Face, faces, tolerance), "distance": distance}));
|
||||
r
|
||||
}
|
||||
|
||||
/// A sheet thickened into a solid by `thickness` along its surfaces' normals (negative:
|
||||
/// against them), or by half each way when `symmetric`, with ruled walls along its open
|
||||
/// edges. A closed solid is [`Error::Argument`].
|
||||
pub fn thicken(&self, thickness: f64, symmetric: bool) -> Result<Brep> {
|
||||
core::offset::thicken(self.core(), thickness, symmetric).map(Brep::made_core)
|
||||
let r = core::offset::thicken(self.core(), thickness, symmetric).map(Brep::made_core);
|
||||
trace::made("thicken", &[self], &r, || json!({"thickness": thickness, "symmetric": symmetric}));
|
||||
r
|
||||
}
|
||||
|
||||
/// This body with its topological edges and vertices removed (SMLib's
|
||||
@@ -240,7 +335,9 @@ impl Brep {
|
||||
if keep.len() > MAX_POINTS {
|
||||
return Err(Error::Argument);
|
||||
}
|
||||
core::merge::merge_faces(self.core(), keep, tolerance).map(Brep::made_core)
|
||||
let r = core::merge::merge_faces(self.core(), keep, tolerance).map(Brep::made_core);
|
||||
trace::made("merge_faces", &[self], &r, || json!({"keep": trace::picks(self, PickKind::Edge, keep, tolerance)}));
|
||||
r
|
||||
}
|
||||
|
||||
/// The flat faces nearest to `faces` (each within `tolerance`) tilted by `angle` radians
|
||||
@@ -260,7 +357,12 @@ impl Brep {
|
||||
if faces.is_empty() || faces.len() > MAX_POINTS {
|
||||
return Err(Error::Argument);
|
||||
}
|
||||
core::offset::draft(self.core(), faces, tolerance, neutral_origin, neutral_normal, pull, angle).map(Brep::made_core)
|
||||
let r = core::offset::draft(self.core(), faces, tolerance, neutral_origin, neutral_normal, pull, angle).map(Brep::made_core);
|
||||
trace::made("draft", &[self], &r, || {
|
||||
json!({"faces": trace::picks(self, PickKind::Face, faces, tolerance), "neutral_origin": neutral_origin,
|
||||
"neutral_normal": neutral_normal, "pull": pull, "angle": angle})
|
||||
});
|
||||
r
|
||||
}
|
||||
|
||||
/// [`Brep::blend`] and its kin on solidcore (`core::blend::blend`).
|
||||
|
||||
@@ -3,6 +3,9 @@
|
||||
//! tagged inputs ([`Brep::tagged`]) give results whose [`Brep::history`] says where each face and
|
||||
//! edge came from.
|
||||
|
||||
use serde_json::json;
|
||||
|
||||
use crate::trace;
|
||||
use crate::{Brep, Result, core};
|
||||
|
||||
impl Brep {
|
||||
@@ -10,12 +13,16 @@ impl Brep {
|
||||
/// outward where they close into a solid, else only made to agree across their shared edges;
|
||||
/// with whether the result is a closed solid.
|
||||
pub fn stitch(&self, tolerance: f64) -> Result<(Brep, bool)> {
|
||||
core::merge::stitch(self.core(), tolerance).map(|(b, closed)| (Brep::made_core(b), closed))
|
||||
let r = core::merge::stitch(self.core(), tolerance).map(|(b, closed)| (Brep::made_core(b), closed));
|
||||
trace::call("stitch", &[self], &r, |(b, _)| vec![b.id], || json!({"tolerance": tolerance}));
|
||||
r
|
||||
}
|
||||
|
||||
/// This sheet with every face moved onto its surface's offset by `distance` along its normal
|
||||
/// (negative: against it). A closed solid is [`crate::Error::Argument`].
|
||||
pub fn offset_sheet(&self, distance: f64) -> Result<Brep> {
|
||||
core::offset::offset_sheet(self.core(), distance).map(Brep::made_core)
|
||||
let r = core::offset::offset_sheet(self.core(), distance).map(Brep::made_core);
|
||||
trace::made("offset_sheet", &[self], &r, || json!({"distance": distance}));
|
||||
r
|
||||
}
|
||||
}
|
||||
|
||||
@@ -3,6 +3,9 @@
|
||||
//! taken over its whole domain.
|
||||
|
||||
use crate::ssi::Surface;
|
||||
use serde_json::json;
|
||||
|
||||
use crate::trace;
|
||||
use crate::{Brep, Error, Result, core};
|
||||
|
||||
impl Brep {
|
||||
@@ -15,7 +18,15 @@ impl Brep {
|
||||
return Err(Error::Argument);
|
||||
}
|
||||
let specs: Vec<&crate::ssi::Spec> = tools.iter().map(|t| t.spec()).collect();
|
||||
core::split::split_faces(self.core(), faces, &specs).map(|r| r.map(|(b, made)| (Brep::made_core(b), made)))
|
||||
let r = core::split::split_faces(self.core(), faces, &specs).map(|r| r.map(|(b, made)| (Brep::made_core(b), made)));
|
||||
trace::call(
|
||||
"split_faces",
|
||||
&[self],
|
||||
&r,
|
||||
|o| o.iter().map(|(b, _)| b.id).collect(),
|
||||
|| json!({"faces": faces, "tools": specs.iter().map(|s| trace::surface(s)).collect::<Vec<_>>()}),
|
||||
);
|
||||
r
|
||||
}
|
||||
|
||||
/// The manifold solid `self` cut in two by `tool` (whose domain must reach past it): the
|
||||
@@ -24,7 +35,15 @@ impl Brep {
|
||||
/// leaves both parts the whole body, with no face from the tool (tag `self` to tell); `None`
|
||||
/// when a side is left empty.
|
||||
pub fn split_body(&self, tool: &Surface) -> Result<Option<(Brep, Brep)>> {
|
||||
core::split::split_body(self.core(), tool.spec()).map(|r| r.map(|(b, f)| (Brep::made_core(b), Brep::made_core(f))))
|
||||
let r = core::split::split_body(self.core(), tool.spec()).map(|r| r.map(|(b, f)| (Brep::made_core(b), Brep::made_core(f))));
|
||||
trace::call(
|
||||
"split_body",
|
||||
&[self],
|
||||
&r,
|
||||
|o| o.iter().flat_map(|(b, f)| [b.id, f.id]).collect(),
|
||||
|| json!({"tool": trace::surface(tool.spec())}),
|
||||
);
|
||||
r
|
||||
}
|
||||
|
||||
/// The manifold solid `self` cut in two by the sheet `sheet` as it is (its faces joined edge
|
||||
@@ -33,6 +52,8 @@ impl Brep {
|
||||
/// normal and the part in front. A `sheet` that is no sheet, or a `face` it does not have, is
|
||||
/// [`Error::Argument`].
|
||||
pub fn split_body_by_sheet(&self, sheet: &Brep, face: usize) -> Result<Option<(Brep, Brep)>> {
|
||||
core::split::split_body_by_sheet(self.core(), sheet.core(), face).map(|r| r.map(|(b, f)| (Brep::made_core(b), Brep::made_core(f))))
|
||||
let r = core::split::split_body_by_sheet(self.core(), sheet.core(), face).map(|r| r.map(|(b, f)| (Brep::made_core(b), Brep::made_core(f))));
|
||||
trace::call("split_body_by_sheet", &[self, sheet], &r, |o| o.iter().flat_map(|(b, f)| [b.id, f.id]).collect(), || json!({"face": face}));
|
||||
r
|
||||
}
|
||||
}
|
||||
|
||||
+84
-10
@@ -6,6 +6,9 @@
|
||||
//! With `cap`, the profile's loops close the ends and the result must be a closed manifold solid
|
||||
//! ([`Error::NotSolid`] otherwise); without, it is the swept sheet.
|
||||
|
||||
use serde_json::json;
|
||||
|
||||
use crate::trace;
|
||||
use crate::{Brep, Result, core};
|
||||
|
||||
/// A 3D curve of a profile, path or section.
|
||||
@@ -105,7 +108,9 @@ impl Brep {
|
||||
/// A sheet of planar faces bounded by `loops`: closed loops of curves in one plane, in any
|
||||
/// order, nested as outer loops, their holes and islands in the holes.
|
||||
pub fn planar_faces(loops: &[Curve]) -> Result<Brep> {
|
||||
core::sweep::planar_faces(loops).map(Brep::made_core)
|
||||
let r = core::sweep::planar_faces(loops).map(Brep::made_core);
|
||||
trace::made("planar_faces", &[], &r, || json!({"loops": trace::curves(loops)}));
|
||||
r
|
||||
}
|
||||
|
||||
/// The planar `profile` extruded `distance` along the unit `direction` (square to its plane).
|
||||
@@ -116,20 +121,43 @@ impl Brep {
|
||||
/// [`DraftCorner::Curvature`], a curve of a profile with a sharp corner is neither a line nor
|
||||
/// an arc).
|
||||
pub fn extrude(profile: &[Curve], direction: [f64; 3], distance: f64, draft: f64, corner: DraftCorner, cap: bool) -> Result<Brep> {
|
||||
core::sweep::extrude(profile, direction, distance, draft, corner, cap).map(Brep::made_core)
|
||||
let r = core::sweep::extrude(profile, direction, distance, draft, corner, cap).map(Brep::made_core);
|
||||
trace::made("extrude", &[], &r, || {
|
||||
let corner = match corner {
|
||||
DraftCorner::Curvature => "curvature",
|
||||
DraftCorner::Tangent => "tangent",
|
||||
DraftCorner::Round => "round",
|
||||
};
|
||||
json!({"profile": trace::curves(profile), "direction": direction, "distance": distance, "draft": draft, "corner": corner, "cap": cap})
|
||||
});
|
||||
r
|
||||
}
|
||||
|
||||
/// The planar `profile` turned `angle` radians (0 < angle <= 2 pi) right-handed about the
|
||||
/// axis through `origin` along `direction`, in the profile's plane (touching it at most).
|
||||
pub fn revolve(profile: &[Curve], origin: [f64; 3], direction: [f64; 3], angle: f64, cap: bool) -> Result<Brep> {
|
||||
core::sweep::revolve(profile, origin, direction, angle, cap).map(Brep::made_core)
|
||||
let r = core::sweep::revolve(profile, origin, direction, angle, cap).map(Brep::made_core);
|
||||
trace::made(
|
||||
"revolve",
|
||||
&[],
|
||||
&r,
|
||||
|| json!({"profile": trace::curves(profile), "origin": origin, "direction": direction, "angle": angle, "cap": cap}),
|
||||
);
|
||||
r
|
||||
}
|
||||
|
||||
/// `profile` swept along `path` (end-to-end curves), carried with the path's start: the
|
||||
/// profile keeps its place relative to it. The walls are B-spline approximations, one per
|
||||
/// stretch of profile between tangent breaks.
|
||||
pub fn sweep(profile: &[Curve], path: &[Curve], frame: SweepFrame, cap: bool) -> Result<Brep> {
|
||||
core::sweep::sweep_placed(profile, path, frame, cap).map(|(b, _)| Brep::made_core(b))
|
||||
let r = core::sweep::sweep_placed(profile, path, frame, cap).map(|(b, _)| Brep::made_core(b));
|
||||
trace::made(
|
||||
"sweep",
|
||||
&[],
|
||||
&r,
|
||||
|| json!({"profile": trace::curves(profile), "path": trace::curves(path), "frame": frame_word(frame), "cap": cap}),
|
||||
);
|
||||
r
|
||||
}
|
||||
|
||||
/// [`Brep::sweep`], with where the sweep placed the profile: the rigid motions carrying the
|
||||
@@ -138,7 +166,15 @@ impl Brep {
|
||||
/// out from point to point along the path); a sweep that carries on from where this one left
|
||||
/// the profile starts from the last.
|
||||
pub fn sweep_placed(profile: &[Curve], path: &[Curve], frame: SweepFrame, cap: bool) -> Result<(Brep, [Affine; 3])> {
|
||||
core::sweep::sweep_placed(profile, path, frame, cap).map(|(b, m)| (Brep::made_core(b), m))
|
||||
let r = core::sweep::sweep_placed(profile, path, frame, cap).map(|(b, m)| (Brep::made_core(b), m));
|
||||
trace::call(
|
||||
"sweep",
|
||||
&[],
|
||||
&r,
|
||||
|(b, _)| vec![b.id],
|
||||
|| json!({"profile": trace::curves(profile), "path": trace::curves(path), "frame": frame_word(frame), "cap": cap}),
|
||||
);
|
||||
r
|
||||
}
|
||||
|
||||
/// The `curves` projected along `direction` (pointing from them toward the face) onto the
|
||||
@@ -173,27 +209,52 @@ impl Brep {
|
||||
/// A loft (skin) through `sections` (at least two closed loops), `degree` (1 ruled, 2 or 3)
|
||||
/// across them.
|
||||
pub fn loft(sections: &[Vec<Curve>], degree: u32, cap: bool) -> Result<Brep> {
|
||||
core::sweep::loft(sections, degree, cap).map(Brep::made_core)
|
||||
let r = core::sweep::loft(sections, degree, cap).map(Brep::made_core);
|
||||
trace::made(
|
||||
"loft",
|
||||
&[],
|
||||
&r,
|
||||
|| json!({"sections": sections.iter().map(|s| trace::curves(s)).collect::<Vec<_>>(), "degree": degree, "cap": cap}),
|
||||
);
|
||||
r
|
||||
}
|
||||
|
||||
/// The planar `profile` placed by each of `stations` in turn (2…[`MAX_STATIONS`], each
|
||||
/// section exactly the profile's image), its walls skinned through the sections, cubic
|
||||
/// across them: one wall per profile curve. `ends` says how the ends close.
|
||||
pub fn sweep_stations(profile: &[Curve], stations: &[Affine], ends: Ends) -> Result<Brep> {
|
||||
core::sweep::sweep_stations(profile, stations, ends).map(Brep::made_core)
|
||||
let r = core::sweep::sweep_stations(profile, stations, ends).map(Brep::made_core);
|
||||
trace::made("sweep_stations", &[], &r, || {
|
||||
let ends = match ends {
|
||||
Ends::Open => "open",
|
||||
Ends::Capped => "capped",
|
||||
Ends::Joined => "joined",
|
||||
};
|
||||
json!({"profile": trace::curves(profile), "stations": stations.iter().map(trace::affine).collect::<Vec<_>>(), "ends": ends})
|
||||
});
|
||||
r
|
||||
}
|
||||
|
||||
/// A loft from the planar `section` (one closed loop of lines, in order) to the point `apex`
|
||||
/// off its plane: a pyramid, its base the section and a triangle on each line.
|
||||
pub fn loft_to_point(section: &[Curve], apex: [f64; 3]) -> Result<Brep> {
|
||||
core::sweep::loft_to_point(section, apex).map(Brep::made_core)
|
||||
let r = core::sweep::loft_to_point(section, apex).map(Brep::made_core);
|
||||
trace::made("loft_to_point", &[], &r, || json!({"section": trace::curves(section), "apex": apex}));
|
||||
r
|
||||
}
|
||||
|
||||
/// `profile` carried by a screw motion about the axis through `origin` along `direction`:
|
||||
/// `turns` right-handed turns about it, rising `pitch` (signed) per turn, capped at both ends,
|
||||
/// its walls within about `tolerance` of the true screw surfaces.
|
||||
pub fn screw_sweep(profile: &[Curve], origin: [f64; 3], direction: [f64; 3], pitch: f64, turns: f64, tolerance: f64) -> Result<Brep> {
|
||||
core::sweep::screw_sweep(profile, origin, direction, pitch, turns, None, tolerance).map(Brep::made_core)
|
||||
let r = core::sweep::screw_sweep(profile, origin, direction, pitch, turns, None, tolerance).map(Brep::made_core);
|
||||
trace::made(
|
||||
"screw_sweep",
|
||||
&[],
|
||||
&r,
|
||||
|| json!({"profile": trace::curves(profile), "origin": origin, "direction": direction, "pitch": pitch, "turns": turns, "tolerance": tolerance}),
|
||||
);
|
||||
r
|
||||
}
|
||||
|
||||
/// [`screw_sweep`](Self::screw_sweep) with the profile moved off the axis as it turns: at turn
|
||||
@@ -211,7 +272,20 @@ impl Brep {
|
||||
law: &[(f64, f64)],
|
||||
tolerance: f64,
|
||||
) -> Result<Brep> {
|
||||
core::sweep::screw_sweep(profile, origin, direction, pitch, turns, Some(law), tolerance).map(Brep::made_core)
|
||||
let r = core::sweep::screw_sweep(profile, origin, direction, pitch, turns, Some(law), tolerance).map(Brep::made_core);
|
||||
trace::made("screw_sweep", &[], &r, || {
|
||||
json!({"profile": trace::curves(profile), "origin": origin, "direction": direction, "pitch": pitch, "turns": turns,
|
||||
"law": law, "tolerance": tolerance})
|
||||
});
|
||||
r
|
||||
}
|
||||
}
|
||||
|
||||
/// A sweep frame's name in a trace.
|
||||
fn frame_word(f: SweepFrame) -> &'static str {
|
||||
match f {
|
||||
SweepFrame::Follow => "follow",
|
||||
SweepFrame::Translate => "translate",
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,225 @@
|
||||
//! A trace of the operations a run makes on this crate's bodies, for the kernel rig's corpus
|
||||
//! (`solidcraft-cli kernel-cases --export`): each body taken from a record (its record), each
|
||||
//! operation (its name, its operand bodies, its parameters with every pick by points also given
|
||||
//! as the topology index it picked, and the bodies it made or why it failed), and each body
|
||||
//! written back as a record. Off unless [`start`]ed; while off it costs an atomic load per
|
||||
//! operation.
|
||||
//!
|
||||
//! Bodies are named by a number each gets when it is made ([`crate::Brep`]'s id), so a trace
|
||||
//! says which operation's output went into which operation, and which record each became.
|
||||
|
||||
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
|
||||
use std::sync::{Mutex, PoisonError};
|
||||
|
||||
use serde_json::{Value, json};
|
||||
use solidcraft_geom::brep as b;
|
||||
|
||||
use crate::sweeps::{Affine, Curve};
|
||||
use crate::{Brep, Result};
|
||||
|
||||
static ON: AtomicBool = AtomicBool::new(false);
|
||||
static NEXT: AtomicU64 = AtomicU64::new(1);
|
||||
static LOG: Mutex<Vec<Event>> = Mutex::new(Vec::new());
|
||||
|
||||
/// One thing a traced run did, in the order it happened.
|
||||
#[derive(Clone, Debug)]
|
||||
pub enum Event {
|
||||
/// Body `id` was made from `record` ([`Brep::from_record`]).
|
||||
Import { id: u64, record: Box<b::Brep>, trusted: bool, keeping_splines: bool },
|
||||
/// An operation: its name, its operand bodies, its parameters, and the bodies it made
|
||||
/// (`Ok`) or its error's message (`Err`).
|
||||
Call { op: &'static str, inputs: Vec<u64>, params: Value, outputs: std::result::Result<Vec<u64>, String> },
|
||||
/// Body `id` was written as `record` ([`Brep::to_native`] and its kin).
|
||||
Export { id: u64, record: Box<b::Brep> },
|
||||
}
|
||||
|
||||
/// Starts a trace, dropping anything an earlier one left.
|
||||
pub fn start() {
|
||||
LOG.lock().unwrap_or_else(PoisonError::into_inner).clear();
|
||||
ON.store(true, Ordering::SeqCst);
|
||||
}
|
||||
|
||||
/// Stops the trace and hands over what it recorded.
|
||||
pub fn finish() -> Vec<Event> {
|
||||
ON.store(false, Ordering::SeqCst);
|
||||
std::mem::take(&mut *LOG.lock().unwrap_or_else(PoisonError::into_inner))
|
||||
}
|
||||
|
||||
/// The names of solidcore's upstream fixes this crate turns on: the fix set every traced
|
||||
/// operation ran with.
|
||||
pub fn fixes() -> Vec<&'static str> {
|
||||
crate::core::fixes().flags().filter(|&(_, on)| on).map(|(name, _)| name).collect()
|
||||
}
|
||||
|
||||
pub(crate) fn on() -> bool {
|
||||
ON.load(Ordering::Relaxed)
|
||||
}
|
||||
|
||||
/// A new body's number.
|
||||
pub(crate) fn next_id() -> u64 {
|
||||
NEXT.fetch_add(1, Ordering::Relaxed)
|
||||
}
|
||||
|
||||
fn push(e: Event) {
|
||||
LOG.lock().unwrap_or_else(PoisonError::into_inner).push(e);
|
||||
}
|
||||
|
||||
pub(crate) fn imported(r: &Result<Brep>, record: &b::Brep, trusted: bool, keeping_splines: bool) {
|
||||
if !on() {
|
||||
return;
|
||||
}
|
||||
if let Ok(body) = r {
|
||||
push(Event::Import { id: body.id, record: Box::new(record.clone()), trusted, keeping_splines });
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn exported(body: &Brep, record: &b::Brep) {
|
||||
if on() {
|
||||
push(Event::Export { id: body.id, record: Box::new(record.clone()) });
|
||||
}
|
||||
}
|
||||
|
||||
/// Records operation `op` on `inputs`, whose result `r` made the bodies `outputs` reads from it.
|
||||
/// `params` is only built while tracing, after the operation ran.
|
||||
pub(crate) fn call<T>(op: &'static str, inputs: &[&Brep], r: &Result<T>, outputs: impl FnOnce(&T) -> Vec<u64>, params: impl FnOnce() -> Value) {
|
||||
if !on() {
|
||||
return;
|
||||
}
|
||||
let outputs = match r {
|
||||
Ok(v) => Ok(outputs(v)),
|
||||
Err(e) => Err(e.to_string()),
|
||||
};
|
||||
push(Event::Call { op, inputs: inputs.iter().map(|b| b.id).collect(), params: params(), outputs });
|
||||
}
|
||||
|
||||
/// [`call`] for an operation that makes one body.
|
||||
pub(crate) fn made(op: &'static str, inputs: &[&Brep], r: &Result<Brep>, params: impl FnOnce() -> Value) {
|
||||
call(op, inputs, r, |b| vec![b.id], params);
|
||||
}
|
||||
|
||||
/// [`call`] for an operation that may make no body.
|
||||
pub(crate) fn maybe(op: &'static str, inputs: &[&Brep], r: &Result<Option<Brep>>, params: impl FnOnce() -> Value) {
|
||||
call(op, inputs, r, |b| b.iter().map(|b| b.id).collect(), params);
|
||||
}
|
||||
|
||||
/// What a pick by points is of.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub(crate) enum PickKind {
|
||||
Edge,
|
||||
Face,
|
||||
Vertex,
|
||||
}
|
||||
|
||||
/// What one point picked: the entity's index in the body's list of its kind, and where it is
|
||||
/// (an edge's end points, a vertex's point), or why it picked none.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct Pick {
|
||||
pub index: Option<usize>,
|
||||
pub at: Vec<[f64; 3]>,
|
||||
pub miss: Option<&'static str>,
|
||||
}
|
||||
|
||||
impl Pick {
|
||||
pub(crate) fn missed(why: &'static str) -> Pick {
|
||||
Pick { index: None, at: Vec::new(), miss: Some(why) }
|
||||
}
|
||||
}
|
||||
|
||||
/// The points of a pick on `body` and what each picked: `{"points", "tolerance", "picked"}`,
|
||||
/// each of `picked` `{"index", "at"}` or `{"miss"}`.
|
||||
pub(crate) fn picks(body: &Brep, kind: PickKind, points: &[[f64; 3]], tolerance: f64) -> Value {
|
||||
let picked = match crate::core::picked::picks(body.core(), kind, points, tolerance) {
|
||||
Ok(p) => Value::Array(
|
||||
p.into_iter()
|
||||
.map(|p| match (p.index, p.miss) {
|
||||
(Some(i), _) => json!({"index": i, "at": p.at}),
|
||||
(None, why) => json!({"miss": why.unwrap_or("none")}),
|
||||
})
|
||||
.collect(),
|
||||
),
|
||||
Err(e) => json!({"error": e.to_string()}),
|
||||
};
|
||||
let kind = match kind {
|
||||
PickKind::Edge => "edge",
|
||||
PickKind::Face => "face",
|
||||
PickKind::Vertex => "vertex",
|
||||
};
|
||||
json!({"kind": kind, "points": points, "tolerance": tolerance, "picked": picked})
|
||||
}
|
||||
|
||||
/// A profile, path or section curve as data.
|
||||
pub(crate) fn curve(c: &Curve) -> Value {
|
||||
match c {
|
||||
Curve::Line { start, end } => json!({"line": {"start": start, "end": end}}),
|
||||
Curve::Arc { center, axis, reference, radius, start, end } => {
|
||||
json!({"arc": {"center": center, "axis": axis, "reference": reference, "radius": radius, "start": start, "end": end}})
|
||||
}
|
||||
Curve::Nurbs { degree, points, knots } => json!({"nurbs": {"degree": degree, "points": points, "knots": knots}}),
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn curves(cs: &[Curve]) -> Value {
|
||||
Value::Array(cs.iter().map(curve).collect())
|
||||
}
|
||||
|
||||
pub(crate) fn affine(a: &Affine) -> Value {
|
||||
json!({"m": a.m, "t": a.t})
|
||||
}
|
||||
|
||||
/// A split tool's surface as data.
|
||||
pub(crate) fn surface(s: &crate::ssi::Spec) -> Value {
|
||||
use crate::ssi::Spec;
|
||||
match s {
|
||||
Spec::Plane { origin, xaxis, yaxis, u, v } => json!({"plane": {"origin": origin, "xaxis": xaxis, "yaxis": yaxis, "u": u, "v": v}}),
|
||||
Spec::Cylinder { origin, xaxis, yaxis, radius, angle_deg, height } => {
|
||||
json!({"cylinder": {"origin": origin, "xaxis": xaxis, "yaxis": yaxis, "radius": radius, "angle_deg": angle_deg, "height": height}})
|
||||
}
|
||||
Spec::Cone { apex, xaxis, yaxis, half_angle_deg, height } => {
|
||||
json!({"cone": {"apex": apex, "xaxis": xaxis, "yaxis": yaxis, "half_angle_deg": half_angle_deg, "height": height}})
|
||||
}
|
||||
Spec::Sphere { center, xaxis, yaxis, radius, lon_deg, lat_deg } => {
|
||||
json!({"sphere": {"center": center, "xaxis": xaxis, "yaxis": yaxis, "radius": radius, "lon_deg": lon_deg, "lat_deg": lat_deg}})
|
||||
}
|
||||
Spec::Torus { center, xaxis, yaxis, major_radius, minor_radius, major_deg, minor_deg } => json!({"torus": {
|
||||
"center": center, "xaxis": xaxis, "yaxis": yaxis, "major_radius": major_radius, "minor_radius": minor_radius,
|
||||
"major_deg": major_deg, "minor_deg": minor_deg}}),
|
||||
Spec::Nurbs { degree, nu, nv, knots_u, knots_v, points, weights } => json!({"nurbs": {
|
||||
"degree": degree, "nu": nu, "nv": nv, "knots_u": knots_u, "knots_v": knots_v, "points": points, "weights": weights}}),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// A traced fillet names its operand, its output and the edge its point picked, by index and
|
||||
/// end points; the record its output was written as and the body read back from it are
|
||||
/// traced under their own numbers. Other tests' operations may land in the trace too: only
|
||||
/// these bodies' events are read.
|
||||
#[test]
|
||||
fn a_fillet_is_traced_with_its_pick_and_records() {
|
||||
let block = Brep::make_box([0.0; 3], [10.0, 20.0, 30.0]).unwrap();
|
||||
start();
|
||||
let round = block.fillet(&[[10.0, 10.0, 30.0]], 1e-3, 2.0).unwrap();
|
||||
let record = round.to_native().unwrap();
|
||||
let again = Brep::from_record(&record, true).unwrap();
|
||||
let events = finish();
|
||||
let call = events
|
||||
.iter()
|
||||
.find_map(|e| match e {
|
||||
Event::Call { op: "fillet", inputs, params, outputs } if inputs == &vec![block.id] => Some((params, outputs)),
|
||||
_ => None,
|
||||
})
|
||||
.unwrap();
|
||||
assert_eq!(call.1, &Ok(vec![round.id]));
|
||||
let picked = &call.0["edges"]["picked"][0];
|
||||
assert!(picked["index"].as_u64().is_some(), "{picked}");
|
||||
// The point (10, 10, 30) is on the top edge x = 10, z = 30, from y = 0 to y = 20.
|
||||
let mut ends: Vec<Vec<f64>> = picked["at"].as_array().unwrap().iter().map(|p| serde_json::from_value(p.clone()).unwrap()).collect();
|
||||
ends.sort_by(|a, b| a[1].total_cmp(&b[1]));
|
||||
assert_eq!(ends, vec![vec![10.0, 0.0, 30.0], vec![10.0, 20.0, 30.0]]);
|
||||
assert!(events.iter().any(|e| matches!(e, Event::Export { id, record: r } if *id == round.id && **r == record)));
|
||||
assert!(events.iter().any(|e| matches!(e, Event::Import { id, record: r, trusted: true, .. } if *id == again.id && **r == record)));
|
||||
assert_ne!(again.id, round.id);
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,9 @@
|
||||
//! Untrim and extend of a sheet's faces. Each returns a new body and leaves its input unchanged;
|
||||
//! faces and holes are chosen by points, as [`crate::ops`] chooses them.
|
||||
|
||||
use serde_json::json;
|
||||
|
||||
use crate::trace;
|
||||
use crate::{Brep, Result, core};
|
||||
|
||||
/// How [`Brep::extend_sheet`] continues a surface past its side.
|
||||
@@ -33,7 +36,14 @@ impl Brep {
|
||||
Holes::All => None,
|
||||
Holes::At(at) => Some(at),
|
||||
};
|
||||
core::trim::untrim_face(self.core(), point, tolerance, holes, outer, in_place).map(Brep::made_core)
|
||||
let r = core::trim::untrim_face(self.core(), point, tolerance, holes, outer, in_place).map(Brep::made_core);
|
||||
trace::made(
|
||||
"untrim_face",
|
||||
&[self],
|
||||
&r,
|
||||
|| json!({"face": trace::picks(self, trace::PickKind::Face, &[point], tolerance), "holes": holes, "outer": outer, "in_place": in_place}),
|
||||
);
|
||||
r
|
||||
}
|
||||
|
||||
/// The one-face sheet `self`, whose face is its surface's whole parameter box, continued
|
||||
@@ -41,7 +51,16 @@ impl Brep {
|
||||
/// `how` says: SMLib's extended surface over the grown box, the face and its sides carrying
|
||||
/// the tags of those they continue. A sheet of another shape is [`crate::Error::Unsupported`].
|
||||
pub fn extend_sheet(&self, point: [f64; 3], tolerance: f64, distance: f64, how: Continuation) -> Result<Brep> {
|
||||
core::trim::extend_sheet(self.core(), point, tolerance, distance, how).map(Brep::made_core)
|
||||
let r = core::trim::extend_sheet(self.core(), point, tolerance, distance, how).map(Brep::made_core);
|
||||
trace::made("extend_sheet", &[self], &r, || {
|
||||
let how = match how {
|
||||
Continuation::Natural => "natural",
|
||||
Continuation::Tangent => "tangent",
|
||||
Continuation::Curvature => "curvature",
|
||||
};
|
||||
json!({"edge": trace::picks(self, trace::PickKind::Edge, &[point], tolerance), "distance": distance, "how": how})
|
||||
});
|
||||
r
|
||||
}
|
||||
|
||||
/// A point inside each face, in SMLib's face order: on the face's surface, inside its trims
|
||||
|
||||
@@ -35,6 +35,9 @@ pub(crate) struct Options {
|
||||
/// `--validation MODE`: when SMLib's full check runs on the cases' features (each_step,
|
||||
/// each_feature, off; the CLI's default, each_feature, when not given).
|
||||
validation: Option<String>,
|
||||
/// `--export DIR`: each case's corpus entry for solidcore's rig into DIR (`solidcraft-cli
|
||||
/// kernel-cases --export`), then DIR/manifest.json; no report is written.
|
||||
pub(crate) export: Option<PathBuf>,
|
||||
}
|
||||
|
||||
/// The run's options; `out` is its output folder unless `--out` gives one.
|
||||
@@ -54,7 +57,11 @@ pub(crate) fn options(rest: &[&str], out: &str) -> Result<Options, String> {
|
||||
if let Some(v) = validation.as_deref().filter(|v| !["each_step", "each_feature", "off"].contains(v)) {
|
||||
return Err(format!("--validation must be each_step, each_feature or off, not `{v}`"));
|
||||
}
|
||||
Ok(Options { cli: arg("--cli"), area: arg("--area"), timeout: Duration::from_secs(secs), jobs, out, known_failing, validation })
|
||||
let export = arg("--export").map(|p| {
|
||||
let p = PathBuf::from(p);
|
||||
if p.is_absolute() { p } else { root().join(p) }
|
||||
});
|
||||
Ok(Options { cli: arg("--cli"), area: arg("--area"), timeout: Duration::from_secs(secs), jobs, out, known_failing, validation, export })
|
||||
}
|
||||
|
||||
/// Every case's full result as JSON, into the run's output folder.
|
||||
@@ -151,6 +158,11 @@ fn run_case(o: &Options, case: &Path) -> Value {
|
||||
if let Some(v) = &o.validation {
|
||||
cmd.arg(format!("--validation={v}"));
|
||||
}
|
||||
if let Some(d) = &o.export {
|
||||
let mut export = std::ffi::OsString::from("--export=");
|
||||
export.push(d);
|
||||
cmd.arg(export);
|
||||
}
|
||||
cmd.arg(&rel).stdout(Stdio::piped()).stderr(Stdio::piped());
|
||||
let base = |status: &str, error: String| {
|
||||
let area = case.parent().and_then(|p| p.file_name()).map(|n| n.to_string_lossy().to_string()).unwrap_or_default();
|
||||
@@ -405,6 +417,10 @@ pub fn run(rest: &[&str]) -> Result<(), String> {
|
||||
}
|
||||
let results = run_all(&o, &list);
|
||||
save_results(&o, &results)?;
|
||||
if let Some(d) = &o.export {
|
||||
println!("{}", crate::kernel_corpus::manifest(d, &results, None)?);
|
||||
return Ok(());
|
||||
}
|
||||
if let Some(file) = &o.known_failing {
|
||||
// A gate run grades the run against its baseline, and writes no report; its results.json
|
||||
// is still saved above.
|
||||
|
||||
@@ -0,0 +1,172 @@
|
||||
//! `cargo xtask kernel-cases [--ladder] --export DIR`: the kernel rig as a corpus for solidcore's
|
||||
//! own rig. Each case's process writes its entry (`solidcraft-cli kernel-cases --export`,
|
||||
//! `DIR/<area>/<case>.json`: the kernel operations that made its result, their operand records,
|
||||
//! the fix set, its expected values and the rig's result). This writes what that leaves out:
|
||||
//! an entry for each case whose process left none (a hang or a crash, so no trace), each ladder
|
||||
//! case's golden, and `DIR/manifest.json`, the counts per area and every case that is not
|
||||
//! expressible as kernel input, with its reasons.
|
||||
|
||||
use std::collections::BTreeMap;
|
||||
use std::path::Path;
|
||||
|
||||
use serde_json::{Value, json};
|
||||
|
||||
use crate::kernel_cases::read;
|
||||
use crate::root;
|
||||
|
||||
/// The kind of reason a case is not expressible, for the counts per area.
|
||||
fn reason_kind(why: &str) -> &'static str {
|
||||
if why.starts_with("SolidCraft has no command") {
|
||||
"SolidCraft has no command for it yet"
|
||||
} else if why.starts_with("graded on what SolidCraft computes") {
|
||||
"graded on SolidCraft's own measures (continuity, mesh, files, command answers, construction, flat pattern)"
|
||||
} else if why.contains("graded merged across analytic surfaces") {
|
||||
"counts graded merged across analytic surfaces (SolidCraft's merged_topology)"
|
||||
} else if why.starts_with("no kernel operation ran before the failure") || why.starts_with("the failure is SolidCraft's") {
|
||||
"refused or failed in SolidCraft, not in a kernel operation"
|
||||
} else if why.contains("is no kernel operation's output nor an operand") {
|
||||
"a final body built or changed by SolidCraft (its own geometry or a change to the kernel's record)"
|
||||
} else if why.starts_with("no kernel operation made a body") || why.starts_with("the case ends with no body") {
|
||||
"no kernel operation makes the result"
|
||||
} else if why.starts_with("the rig's run") {
|
||||
"the rig's run hung or crashed (no trace)"
|
||||
} else {
|
||||
"other"
|
||||
}
|
||||
}
|
||||
|
||||
fn write_json(path: &Path, v: &Value, pretty: bool) -> Result<(), String> {
|
||||
let text = if pretty { serde_json::to_string_pretty(v) } else { serde_json::to_string(v) }.map_err(|e| e.to_string())?;
|
||||
if let Some(dir) = path.parent() {
|
||||
std::fs::create_dir_all(dir).map_err(|e| format!("{}: {e}", dir.display()))?;
|
||||
}
|
||||
std::fs::write(path, text).map_err(|e| format!("{}: {e}", path.display()))
|
||||
}
|
||||
|
||||
/// What `git args` prints in this checkout.
|
||||
fn git(args: &[&str]) -> String {
|
||||
std::process::Command::new("git")
|
||||
.current_dir(root())
|
||||
.args(args)
|
||||
.output()
|
||||
.ok()
|
||||
.map(|o| String::from_utf8_lossy(&o.stdout).trim().to_string())
|
||||
.unwrap_or_default()
|
||||
}
|
||||
|
||||
/// The solidcore rev SolidCraft is pinned to (the workspace `Cargo.toml`).
|
||||
fn solidcore_pin() -> String {
|
||||
let text = std::fs::read_to_string(root().join("Cargo.toml")).unwrap_or_default();
|
||||
text.lines()
|
||||
.find(|l| l.starts_with("solidcore ="))
|
||||
.and_then(|l| l.split("rev = \"").nth(1))
|
||||
.and_then(|r| r.split('"').next())
|
||||
.unwrap_or_default()
|
||||
.to_string()
|
||||
}
|
||||
|
||||
/// Completes the corpus in `dir` after a run with `results` (each with its `path` under
|
||||
/// `tests/kernel-cases/`); `golden`, the ladder's, for a ladder run. Returns the summary.
|
||||
pub(crate) fn manifest(dir: &Path, results: &[Value], golden: Option<&Value>) -> Result<String, String> {
|
||||
let base = root().join("tests/kernel-cases");
|
||||
for r in results {
|
||||
let rel = r["path"].as_str().unwrap_or("");
|
||||
let Some((area, id)) = rel.rsplit_once('/') else { continue };
|
||||
let file = dir.join(area).join(format!("{id}.json"));
|
||||
let mut entry = read(&file);
|
||||
if entry.is_null() {
|
||||
// The case's process left no entry: it hung or crashed before writing one.
|
||||
let want = read(&base.join(rel).join("expected.json"));
|
||||
entry = json!({
|
||||
"case": id, "area": area, "sources": want["sources"], "what": want["what"],
|
||||
"expressible": false,
|
||||
"why_not": [format!("the rig's run {}: {}", r["status"].as_str().unwrap_or("?"), r["error"].as_str().unwrap_or(""))],
|
||||
"expected": want,
|
||||
"rig": {"status": r["status"], "error": r["error"]},
|
||||
"calls": [], "bodies": {}, "result": [], "traced_ops": [], "status": r["status"],
|
||||
});
|
||||
}
|
||||
if let Some(g) = golden.and_then(|g| g["cases"].get(rel)) {
|
||||
// The golden's status and counts; never its time.
|
||||
entry["golden"] = json!({"status": g["status"], "measured": g["measured"], "unstable": g.get("unstable")});
|
||||
}
|
||||
if let Some(e) = r.get("export_error") {
|
||||
entry["export_error"] = e.clone();
|
||||
}
|
||||
write_json(&file, &entry, false)?;
|
||||
}
|
||||
|
||||
// Every entry in the corpus, this run's or an earlier one's.
|
||||
let mut areas: BTreeMap<String, Value> = BTreeMap::new();
|
||||
let mut not: Vec<Value> = Vec::new();
|
||||
let mut stack = vec![dir.to_path_buf()];
|
||||
let mut files = Vec::new();
|
||||
while let Some(d) = stack.pop() {
|
||||
for e in std::fs::read_dir(&d).map_err(|e| format!("{}: {e}", d.display()))?.flatten() {
|
||||
let p = e.path();
|
||||
if p.is_dir() {
|
||||
stack.push(p);
|
||||
} else if p.extension().is_some_and(|x| x == "json") && p.parent() != Some(dir) {
|
||||
files.push(p);
|
||||
}
|
||||
}
|
||||
}
|
||||
files.sort();
|
||||
for f in files {
|
||||
let e = read(&f);
|
||||
let area = e["area"].as_str().unwrap_or("?").to_string();
|
||||
let a = areas.entry(area.clone()).or_insert_with(|| json!({"cases": 0, "expressible": 0, "not_expressible": 0, "chain": {}, "reasons": {}}));
|
||||
a["cases"] = json!(a["cases"].as_u64().unwrap_or(0) + 1);
|
||||
if e["expressible"].as_bool() == Some(true) {
|
||||
a["expressible"] = json!(a["expressible"].as_u64().unwrap_or(0) + 1);
|
||||
let n = e["calls"].as_array().map_or(0, Vec::len).to_string();
|
||||
a["chain"][&n] = json!(a["chain"][&n].as_u64().unwrap_or(0) + 1);
|
||||
} else {
|
||||
a["not_expressible"] = json!(a["not_expressible"].as_u64().unwrap_or(0) + 1);
|
||||
let why: Vec<&str> = e["why_not"].as_array().into_iter().flatten().filter_map(Value::as_str).collect();
|
||||
let mut kinds: Vec<&str> = why.iter().map(|w| reason_kind(w)).collect();
|
||||
kinds.sort();
|
||||
kinds.dedup();
|
||||
for k in kinds {
|
||||
a["reasons"][k] = json!(a["reasons"][k].as_u64().unwrap_or(0) + 1);
|
||||
}
|
||||
not.push(json!({"case": format!("{area}/{}", e["case"].as_str().unwrap_or("?")), "why": why}));
|
||||
}
|
||||
}
|
||||
let m = json!({
|
||||
"solidcraft": git(&["rev-parse", "HEAD"]),
|
||||
"solidcore": solidcore_pin(),
|
||||
"fixes": "fixes.json",
|
||||
"areas": areas,
|
||||
"not_expressible": not,
|
||||
});
|
||||
write_json(&dir.join("manifest.json"), &m, true)?;
|
||||
let mut text = String::from("area cases expressible not\n");
|
||||
for (area, a) in &areas {
|
||||
text += &format!(
|
||||
"{area:<20} {:>5} {:>11} {:>3}\n",
|
||||
a["cases"].as_u64().unwrap_or(0),
|
||||
a["expressible"].as_u64().unwrap_or(0),
|
||||
a["not_expressible"].as_u64().unwrap_or(0)
|
||||
);
|
||||
}
|
||||
Ok(text)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn every_reason_the_export_gives_has_its_kind() {
|
||||
for (why, kind) in [
|
||||
("graded on what SolidCraft computes: continuity", "graded on SolidCraft's own measures"),
|
||||
("faces graded merged across analytic surfaces (6), the records have 8", "counts graded merged"),
|
||||
("the failure is SolidCraft's, not a kernel operation's: x", "refused or failed in SolidCraft"),
|
||||
("body \"Body1\" is no kernel operation's output nor an operand: SolidCraft built it", "a final body built or changed"),
|
||||
("the rig's run hang: no result", "the rig's run hung"),
|
||||
] {
|
||||
assert!(reason_kind(why).starts_with(kind), "{why}: {}", reason_kind(why));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -295,6 +295,10 @@ pub fn run(rest: &[&str]) -> Result<(), String> {
|
||||
let list: Vec<PathBuf> = tiers.iter().flat_map(|t| t.cases.iter().map(|c| base.join(c))).collect();
|
||||
let all = run_all(&o, &list);
|
||||
save_results(&o, &all)?;
|
||||
if let Some(d) = &o.export {
|
||||
println!("{}", crate::kernel_corpus::manifest(d, &all, Some(&read(&golden_path())))?);
|
||||
return Ok(());
|
||||
}
|
||||
let results: BTreeMap<String, Value> = all.into_iter().map(|r| (rel_of(&r), r)).collect();
|
||||
let golden = read(&golden_path());
|
||||
if gate_run {
|
||||
|
||||
+6
-1
@@ -11,6 +11,7 @@ mod features;
|
||||
mod i18n;
|
||||
mod icons;
|
||||
mod kernel_cases;
|
||||
mod kernel_corpus;
|
||||
mod kernel_ladder;
|
||||
mod known_failing;
|
||||
mod layers;
|
||||
@@ -49,7 +50,7 @@ commands:
|
||||
replay the reference tests (tests/oracle/*/recipe.json), compare with each
|
||||
case's expected.json and write docs/oracle.md (--cli: a solidcraft-cli
|
||||
already built, instead of cargo run --release)
|
||||
kernel-cases [--area AREA] [--cli BIN] [--timeout S] [--jobs N] [--out DIR] [--known-failing FILE] [--validation MODE] [--coverage]
|
||||
kernel-cases [--area AREA] [--cli BIN] [--timeout S] [--jobs N] [--out DIR] [--known-failing FILE] [--validation MODE] [--coverage] [--export DIR]
|
||||
the kernel regression rig: run every case in tests/kernel-cases/<area>/<id>/ on
|
||||
solidcore (one process each, killed after --timeout, default 180 s), grade it against
|
||||
the case's own answer and write docs/kernel-cases.md; DIR (default
|
||||
@@ -70,6 +71,10 @@ commands:
|
||||
--coverage: instead of running cases, fail on a registry command (the CLI's
|
||||
`commands`, planned ones aside) that no recipe.json under tests/kernel-cases/
|
||||
uses and tests/kernel-cases/EXEMPT does not list, and on a stale EXEMPT line
|
||||
--export DIR: instead of the report, the corpus for solidcore's rig: each case's
|
||||
kernel operations, operand records, fix set and expected values in
|
||||
DIR/<area>/<case>.json and DIR/manifest.json, every case not expressible as
|
||||
kernel input listed with its reasons; with --ladder too
|
||||
known-failing --junit PATH... [--list FILE]
|
||||
grade a nextest run's junit report (a file, or every .xml under a directory)
|
||||
against the tests known to fail today on the default kernel,
|
||||
|
||||
Reference in New Issue
Block a user