From 27d240d58c48b07392a7332d36c877f44bdbffa7 Mon Sep 17 00:00:00 2001 From: jyviko <2501648+jyviko@users.noreply.github.com> Date: Fri, 30 Oct 2026 01:42:31 -0400 Subject: [PATCH] Wave 407/509: Native B-rep: a body is written as it serializes, not through a JSON value (and 3 more) 4 commits, squashed; the originals stay reachable from tag archive/merge-main-develop. - 73b053221 jyviko: Face capture test: extruding a split face in an uncaptured component is refused - 918429c6d jyviko: Sheet machining: a trimmed To Object tool is measured as the prism its record proves - f37b95498 jyviko: Native B-rep: a body is written as it serializes, not through a JSON value - 298869f4d jyviko: Engine tests: the hostile-parameter test builds its starting model once per command Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ --- crates/doc/src/eval_more.rs | 16 +- crates/engine/src/cmd/face_tests.rs | 21 ++ crates/engine/src/tests.rs | 44 ++- crates/kernel/src/lib.rs | 2 +- crates/kernel/src/native.rs | 66 +++- crates/kernel/src/native/binary.rs | 519 ++++++++++++++++++++++++++++ crates/kernel/src/prism_measure.rs | 73 ++++ 7 files changed, 727 insertions(+), 14 deletions(-) diff --git a/crates/doc/src/eval_more.rs b/crates/doc/src/eval_more.rs index 536a9f8bb..377bb8443 100644 --- a/crates/doc/src/eval_more.rs +++ b/crates/doc/src/eval_more.rs @@ -843,9 +843,21 @@ pub(super) fn sheet_eval( } } -/// Current unmodified extrusion caps, including placement, certify the tool's depth. -/// Tessellation can drift in thickness at distant coordinates and cannot certify a slab. +/// The tool's depth along the sketch normal (from `source`), the roundoff of that depth and the +/// tool's current footprint where it differs from the profile: from its current unmodified +/// extrusion caps, including placement, else from its exact record proving it a uniform prism +/// along the normal (a To Object tool trimmed by the body it runs to, whose boolean leaves no +/// extrusion faces: its section is its footprint). Tessellation can drift in thickness at +/// distant coordinates and cannot certify a slab. fn sheet_tool_span(body: &Body, source: &Plane) -> Option<(f64, f64, f64, Option<(Plane, Region2)>)> { + extrusion_tool_span(body, source).or_else(|| { + let prism = kernel::certified_prism_section(body, source).ok().flatten()?; + (prism.tolerance <= 1e-7).then_some((prism.lo, prism.hi, prism.tolerance, Some((*source, prism.region)))) + }) +} + +/// [`sheet_tool_span`] from the tool's extrusion caps. +fn extrusion_tool_span(body: &Body, source: &Plane) -> Option<(f64, f64, f64, Option<(Plane, Region2)>)> { use kernel::FaceSource; #[derive(PartialEq)] enum Signature<'a> { diff --git a/crates/engine/src/cmd/face_tests.rs b/crates/engine/src/cmd/face_tests.rs index e9afe1389..3a0e0d9b9 100644 --- a/crates/engine/src/cmd/face_tests.rs +++ b/crates/engine/src/cmd/face_tests.rs @@ -184,6 +184,27 @@ fn internal_capture_in_another_component_anchors_an_offset_face_by_its_history_n assert_eq!(s.pending_moves, pending); } +/// Extrude from a face in another component whose occurrence has an uncaptured move, where the +/// face has neither a construction certificate nor an exact history name: a half of a box's top +/// that Split Face divided. The face profile would take the legacy path, which can't capture the +/// source's pending position, so the extrude is refused and changes nothing. +#[test] +fn face_extrude_of_a_split_face_in_another_component_refuses_an_uncaptured_source() { + let mut s = Session::default(); + let component = run(&mut s, "component.create", json!({"name":"Source","grounded":false})); + let occurrence = component["occurrence"].as_u64().unwrap(); + run(&mut s, "solid.box", json!({"length":40,"width":30,"height":20,"body_name":"Stock"})); + run(&mut s, "solid.split_face", json!({"faces":[[10,15,20]],"plane":{"origin":[20,0,0],"normal":[1,0,0]}})); + run(&mut s, "component.activate", json!({"component":0})); + run(&mut s, "occurrence.move", json!({"occurrence":occurrence,"translate":[30,0,0],"capture":false})); + let before = s.doc.to_json(); + let pending = s.pending_moves.clone(); + let error = s.execute("solid.extrude", &json!({"face":[40,15,20],"distance":5,"operation":"new"})).unwrap_err(); + assert!(error.to_string().contains("capture the source occurrence position"), "{error}"); + assert_eq!(s.doc.to_json(), before); + assert_eq!(s.pending_moves, pending); +} + #[test] fn repeated_source_face_profile_requires_and_uses_the_exact_active_occurrence() { let mut s = Session::default(); diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index b1ed9117a..8d86118c1 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -736,6 +736,36 @@ pub(crate) fn hostile_values() -> Vec { ] } +/// A copy of `s` as it stands: its design and model (sharing their bodies, as undo does), its +/// undo and redo, its open sketch and the design it was entered from, and its log. +fn copy_with_history(s: &Session) -> Session { + Session { undo: s.undo.clone(), redo: s.redo.clone(), sketch_entry: s.sketch_entry.clone(), log: s.log.clone(), ..s.scratch() } +} + +/// The hostile-parameter test's copy starts where a session built afresh stands: cancelling its +/// sketch and undoing step for step give the same designs, and the copied session is untouched. +#[test] +fn a_copy_with_history_undoes_like_the_session_it_copies() { + let start = |s: &mut Session| { + run(s, "solid.box", json!({"length": 10, "width": 10, "height": 10})); + run(s, "sketch.create", json!({"plane": "XY"})); + run(s, "sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [5, 5]})); + }; + let mut fresh = Session::default(); + start(&mut fresh); + let mut original = Session::default(); + start(&mut original); + let before = original.doc.clone(); + let mut copy = copy_with_history(&original); + for (command, params) in [("sketch.cancel", json!({})), ("edit.undo", json!({})), ("edit.undo", json!({})), ("edit.redo", json!({}))] { + run(&mut fresh, command, params.clone()); + run(&mut copy, command, params); + assert_eq!(*fresh.doc, *copy.doc, "{command}"); + assert_eq!(fresh.active_sketch, copy.active_sketch, "{command}"); + } + assert!(std::sync::Arc::ptr_eq(&original.doc, &before) && original.active_sketch.is_some(), "the copied session is untouched"); +} + /// Every command, every parameter name it documents, every hostile value: no panic escapes and /// no command panics internally. #[test] @@ -880,16 +910,20 @@ fn hostile_params_never_panic() { scope.spawn(|| { let mut internal = Vec::new(); while let Some(&id) = ids.get(next.fetch_add(1, std::sync::atomic::Ordering::Relaxed)) { + // A model with a sketch, a body and an active sketch, so most commands get far. + // Built once per command and copied for each call: SMLib serialises every + // call behind one lock, so building the box for each of the ~3000 calls + // ran one after another on every thread (over half an hour in CI). + let mut start = Session::default(); + let _ = start.execute("solid.box", &json!({"length": 10, "width": 10, "height": 10})); + let _ = start.execute("sketch.create", &json!({"plane": "XY"})); + let _ = start.execute("sketch.rectangle.two_point", &json!({"p0": [0, 0], "p1": [5, 5]})); for v in hostile_values() { for k in keys { if k == "path" && (id.starts_with("parameters.") || id == "timeline.export_script") { continue; // parameter and script files: covered by their own tests (no stray files) } - let mut s = Session::default(); - // A model with a sketch, a body and an active sketch, so most commands get far. - let _ = s.execute("solid.box", &json!({"length": 10, "width": 10, "height": 10})); - let _ = s.execute("sketch.create", &json!({"plane": "XY"})); - let _ = s.execute("sketch.rectangle.two_point", &json!({"p0": [0, 0], "p1": [5, 5]})); + let mut s = copy_with_history(&start); let p = json!({ k: v.clone() }); if let Err(EngineError::Internal(id, msg)) = s.execute(id, &p) { internal.push(format!("{id} {p}: {msg}")); diff --git a/crates/kernel/src/lib.rs b/crates/kernel/src/lib.rs index 6f394c29e..eca49fd84 100644 --- a/crates/kernel/src/lib.rs +++ b/crates/kernel/src/lib.rs @@ -207,7 +207,7 @@ pub use point_path::{ pub use polybool::faceted_boolean; pub use polyhedron::{HalfSpace, convex_polyhedron, draft, offset_faces, shell}; pub use prism::{PLANAR_FIT_TOL, extrude_planar_regions, planar_regions_boolean}; -pub use prism_measure::certified_prism_equivalent; +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 splitface::{SplitTool, split_body, split_faces, split_faces_with_map}; diff --git a/crates/kernel/src/native.rs b/crates/kernel/src/native.rs index 9f166d2db..f7d06860d 100644 --- a/crates/kernel/src/native.rs +++ b/crates/kernel/src/native.rs @@ -68,13 +68,8 @@ pub fn encode_native_body(body: &Body) -> Result> { let saved = SavedBody { solid: body.record().clone(), metadata: metadata::encode(body)?, runtime }; // Structural validation does not invoke another geometric reconstruction. validate_topology(&saved)?; - let value = serde_json::to_value(saved).map_err(invalid)?; - validate_value(&value, 0)?; - if value_nodes(&value) > MAX_VALUES { - return Err(invalid("value budget")); - } let mut out = MAGIC.to_vec(); - binary::write(&value, &mut out, 0)?; + binary::write_serialized(&saved, &mut out)?; Ok(out) }) } @@ -275,6 +270,8 @@ fn validate_value(v: &Value, depth: usize) -> Result<()> { Ok(()) } +/// How many values `v` is (a collection and each of its items): [`MAX_VALUES`] at most. +#[cfg(test)] fn value_nodes(v: &Value) -> usize { match v { Value::Array(a) => a.iter().fold(1usize, |n, v| n.saturating_add(value_nodes(v))), @@ -338,6 +335,63 @@ mod tests { } } + /// The encoding as it was made before the encoder wrote as it serialized: the whole record as + /// a JSON value, checked, then written. + fn encoded_through_a_value(body: &Body) -> Result> { + let runtime = Runtime { size: body.size, coarse_missing: None }; + let saved = SavedBody { solid: body.record().clone(), metadata: metadata::encode(body)?, runtime }; + validate_topology(&saved)?; + let value = serde_json::to_value(saved).map_err(invalid)?; + validate_value(&value, 0)?; + if value_nodes(&value) > MAX_VALUES { + return Err(invalid("value budget")); + } + let mut out = MAGIC.to_vec(); + binary::write(&value, &mut out, 0)?; + Ok(out) + } + + /// Written as it serializes, a body's encoding is the bytes its JSON value gave, byte for + /// byte: plain, blended, cut (history), extruded (face sources), coloured, painted, split + /// along lines, round (spline forms), open, and placed far off. + #[test] + fn the_encoding_is_the_bytes_of_the_record_as_a_json_value() { + use solidcraft_geom::{Loop2, Plane, Region2, Vec2}; + let cube = crate::box_solid(Vec3::ZERO, Vec3::new(40., 30., 10.)).unwrap(); + let rounded = crate::fillet(&cube, &[Vec3::new(20., 0., 10.)], 2.).unwrap(); + let bore = crate::cylinder(Vec3::new(10., 10., -1.), Vec3::Z, 3., 12.).unwrap(); + let cut = crate::boolean(&rounded, &bore, crate::BoolOp::Cut).unwrap().unwrap(); + let region = Region2 { + outer: Loop2::polygon(&[Vec2::ZERO, Vec2::new(20., 0.), Vec2::new(20., 20.), Vec2::new(0., 20.)]), + holes: vec![Loop2::circle(Vec2::new(10., 10.), 4.)], + }; + let extruded = crate::extrude(&Plane::XY, &[region], 0., 5.).unwrap().remove(0); + assert!(extruded.face_sources().is_some_and(|s| s.iter().any(Option::is_some)), "an extrusion carries its face sources"); + assert!(cut.history().is_some(), "a cut carries its history"); + let paint = crate::Paint { opacity: 0.5, faces: vec![crate::FacePaint { face: 1, color: [0.9, 0.1, 0.2], opacity: 0.75 }] }; + let painted = cube.clone().with_color(Some([0.1, 0.5, 0.9])).with_paint(Some(paint)); + let top = (0..cube.face_count()).find(|f| cube.planar_face(*f).is_some_and(|p| p.normal().z > 0.5 && p.origin.z > 9.)).unwrap(); + let split = + crate::split_faces(&cube, &[top], &crate::SplitTool::Plane(Plane::from_normal(Vec3::new(20., 0., 0.), Vec3::X).unwrap())).unwrap(); + let surface = crate::copy_faces(&cube, &[Vec3::new(20., 15., 10.)]).unwrap(); + let far = crate::transform(&cut, Vec3::new(1.0e6, -2.5e5, 3.0e4), Vec3::ZERO, Vec3::Z, 0.7).unwrap(); + let bodies = [ + cube, + rounded, + cut, + extruded, + painted, + split, + surface, + crate::sphere(Vec3::ZERO, 12.).unwrap(), + crate::torus(Vec3::ZERO, 20., 4.).unwrap(), + far, + ]; + for (i, body) in bodies.iter().enumerate() { + assert_eq!(encode_native_body(body).unwrap(), encoded_through_a_value(body).unwrap(), "body {i}"); + } + } + #[test] fn box_and_fillet_have_stable_wire_records() { let cube = crate::box_solid(Vec3::ZERO, Vec3::new(40., 30., 10.)).unwrap(); diff --git a/crates/kernel/src/native/binary.rs b/crates/kernel/src/native/binary.rs index a5e855927..bedb25b1f 100644 --- a/crates/kernel/src/native/binary.rs +++ b/crates/kernel/src/native/binary.rs @@ -61,15 +61,20 @@ pub(super) fn read(input: &mut &[u8], depth: usize, budget: &mut usize) -> Resul _ => return Err(invalid("unknown binary tag")), }) } +#[cfg(test)] fn count(n: usize, out: &mut Vec) -> Result<()> { out.extend_from_slice(&u32::try_from(n).map_err(invalid)?.to_le_bytes()); Ok(()) } +#[cfg(test)] fn text(s: &str, out: &mut Vec) -> Result<()> { count(s.len(), out)?; out.extend_from_slice(s.as_bytes()); Ok(()) } +/// `value` appended to `out`. The encoder writes a body as it serializes +/// ([`write_serialized`]); this writes a value already built, as tests build hostile ones. +#[cfg(test)] pub(super) fn write(value: &Value, out: &mut Vec, depth: usize) -> Result<()> { if depth > 48 || out.len() > MAX_BYTES { return Err(invalid("encoding budget")); @@ -114,3 +119,517 @@ pub(super) fn write(value: &Value, out: &mut Vec, depth: usize) -> Result<() } Ok(()) } + +/// Why a value could not be written (a serde error carries only its message). +#[derive(Debug)] +pub(super) struct WriteError(String); + +impl std::fmt::Display for WriteError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str(&self.0) + } +} + +impl std::error::Error for WriteError {} + +impl serde::ser::Error for WriteError { + fn custom(msg: T) -> Self { + WriteError(msg.to_string()) + } +} + +fn refuse(what: &str) -> WriteError { + WriteError(what.into()) +} + +type Written = std::result::Result; + +/// `value` appended to `out` as the tagged binary value it is as JSON: the bytes [`write`] gives +/// for `serde_json::to_value(value)`, refused where that, the checks on its result +/// (`validate_value`, the [`MAX_VALUES`] budget) or [`write`] refuse. Written as it is +/// serialized, with no JSON value in between: a body's record is millions of values, and building +/// them all first was most of the cost of encoding it. +/// +/// As JSON: a struct or a map is an object of its entries in key order (a JSON object's), its +/// keys strings (a map's keys may be strings, characters, booleans or integers, written as JSON +/// writes such keys); an enum variant without data its name, one with data an object of its name +/// and the data; an option its value or null; bytes an array of numbers. A number is an integer +/// (unsigned from 0 up, signed below) or a finite float; a float that is not finite is null. +/// +/// Refused: nesting past 48, a string over 1 MiB, an array of more than [`MAX_ITEMS`], a float +/// over 1e12 in size, more than [`MAX_VALUES`] values, more than [`MAX_BYTES`] in `out`. +pub(super) fn write_serialized(value: &T, out: &mut Vec) -> Result<()> { + let mut w = Writer { out, values: 0 }; + value.serialize(Ser { w: &mut w, depth: 0 }).map_err(invalid) +} + +struct Writer<'a> { + out: &'a mut Vec, + values: usize, +} + +impl Writer<'_> { + /// Count a value at `depth` and write its tag. + fn start(&mut self, depth: usize, tag: u8) -> Written { + if depth > 48 { + return Err(refuse("nesting")); + } + self.values = self.values.saturating_add(1); + if self.values > MAX_VALUES { + return Err(refuse("value budget")); + } + self.out.push(tag); + self.fits() + } + fn fits(&self) -> Written { + if self.out.len() > MAX_BYTES { Err(refuse("encoding size")) } else { Ok(()) } + } + fn number(&mut self, depth: usize, tag: u8, bits: [u8; 8]) -> Written { + self.start(depth, tag)?; + self.out.extend_from_slice(&bits); + self.fits() + } + fn unsigned(&mut self, depth: usize, v: u64) -> Written { + self.number(depth, 4, v.to_le_bytes()) + } + fn signed(&mut self, depth: usize, v: i64) -> Written { + match u64::try_from(v) { + Ok(u) => self.unsigned(depth, u), + Err(_) => self.number(depth, 3, v.to_le_bytes()), + } + } + fn float(&mut self, depth: usize, v: f64) -> Written { + if !v.is_finite() { + return self.start(depth, 0); + } + if v.abs() > 1e12 { + return Err(refuse("non-finite metadata")); + } + self.number(depth, 5, v.to_le_bytes()) + } + fn length(&mut self, n: usize) -> Written { + self.out.extend_from_slice(&u32::try_from(n).map_err(|_| refuse("length"))?.to_le_bytes()); + self.fits() + } + fn text(&mut self, s: &str) -> Written { + self.length(s.len())?; + self.out.extend_from_slice(s.as_bytes()); + self.fits() + } + fn string(&mut self, depth: usize, s: &str) -> Written { + if s.len() > 1 << 20 { + return Err(refuse("string budget")); + } + self.start(depth, 6)?; + self.text(s) + } + /// Open a collection at `depth`: its tag and room for its count, which goes at the place + /// returned. + fn open(&mut self, depth: usize, tag: u8) -> Written { + self.start(depth, tag)?; + let at = self.out.len(); + self.out.extend_from_slice(&[0; 4]); + self.fits()?; + Ok(at) + } + fn count_at(&mut self, at: usize, n: usize) -> Written { + let n = u32::try_from(n).map_err(|_| refuse("length"))?.to_le_bytes(); + self.out.get_mut(at..at + 4).ok_or_else(|| refuse("count"))?.copy_from_slice(&n); + Ok(()) + } +} + +/// A value to write at a depth. +pub(super) struct Ser<'w, 'a> { + w: &'w mut Writer<'a>, + depth: usize, +} + +impl<'w, 'a> Ser<'w, 'a> { + /// An object of one entry, named `variant`, whose value comes next (at the depth returned). + fn variant(self, variant: &str) -> Written> { + let at = self.w.open(self.depth, 8)?; + self.w.count_at(at, 1)?; + self.w.text(variant)?; + Ok(Ser { w: self.w, depth: self.depth + 1 }) + } + fn array(self) -> Written> { + let at = self.w.open(self.depth, 7)?; + Ok(Array { w: self.w, depth: self.depth, at, items: 0 }) + } + fn object(self) -> Written> { + let at = self.w.open(self.depth, 8)?; + Ok(Object { w: self.w, depth: self.depth, at, entries: Vec::new(), key: None }) + } +} + +/// An array being written: where its count goes, and how many items it has. +pub(super) struct Array<'w, 'a> { + w: &'w mut Writer<'a>, + depth: usize, + at: usize, + items: usize, +} + +impl Array<'_, '_> { + fn item(&mut self, value: &T) -> Written { + self.items += 1; + if self.items > MAX_ITEMS { + return Err(refuse("array budget")); + } + value.serialize(Ser { w: self.w, depth: self.depth + 1 }) + } + fn close(self) -> Written { + self.w.count_at(self.at, self.items) + } +} + +/// An object being written: where its count goes, and each entry's key and where it ends. The +/// entries are written as they come and put in key order when it closes. +pub(super) struct Object<'w, 'a> { + w: &'w mut Writer<'a>, + depth: usize, + at: usize, + entries: Vec<(String, usize)>, + /// The key of the entry whose value comes next. + key: Option, +} + +impl Object<'_, '_> { + fn key(&mut self, key: String) -> Written { + self.w.text(&key)?; + self.key = Some(key); + Ok(()) + } + fn value(&mut self, value: &T) -> Written { + let key = self.key.take().ok_or_else(|| refuse("an object's value without its key"))?; + value.serialize(Ser { w: self.w, depth: self.depth + 1 })?; + self.entries.push((key, self.w.out.len())); + Ok(()) + } + fn entry(&mut self, key: &str, value: &T) -> Written { + self.key(key.to_owned())?; + self.value(value) + } + fn close(self) -> Written { + let Object { w, at, entries, .. } = self; + let first = at + 4; + if !entries.windows(2).all(|p| p[0].0 < p[1].0) { + // In key order, as a JSON object (a map by key) holds them. A key twice would keep + // only its last value there; no record repeats one. + let mut spans: Vec<(&str, usize, usize)> = Vec::with_capacity(entries.len()); + let mut start = first; + for (key, end) in &entries { + spans.push((key.as_str(), start, *end)); + start = *end; + } + spans.sort_by(|a, b| a.0.cmp(b.0)); + if spans.windows(2).any(|p| p[0].0 == p[1].0) { + return Err(refuse("duplicate key")); + } + let written = w.out.split_off(first); + for (_, start, end) in spans { + w.out.extend_from_slice(written.get(start - first..end - first).ok_or_else(|| refuse("object"))?); + } + } + w.count_at(at, entries.len()) + } +} + +/// A map key as JSON writes it: a string. +struct Key; + +impl serde::Serializer for Key { + type Ok = String; + type Error = WriteError; + type SerializeSeq = serde::ser::Impossible; + type SerializeTuple = serde::ser::Impossible; + type SerializeTupleStruct = serde::ser::Impossible; + type SerializeTupleVariant = serde::ser::Impossible; + type SerializeMap = serde::ser::Impossible; + type SerializeStruct = serde::ser::Impossible; + type SerializeStructVariant = serde::ser::Impossible; + + fn serialize_bool(self, v: bool) -> Written { + Ok(v.to_string()) + } + fn serialize_i8(self, v: i8) -> Written { + Ok(v.to_string()) + } + fn serialize_i16(self, v: i16) -> Written { + Ok(v.to_string()) + } + fn serialize_i32(self, v: i32) -> Written { + Ok(v.to_string()) + } + fn serialize_i64(self, v: i64) -> Written { + Ok(v.to_string()) + } + fn serialize_i128(self, v: i128) -> Written { + Ok(v.to_string()) + } + fn serialize_u8(self, v: u8) -> Written { + Ok(v.to_string()) + } + fn serialize_u16(self, v: u16) -> Written { + Ok(v.to_string()) + } + fn serialize_u32(self, v: u32) -> Written { + Ok(v.to_string()) + } + fn serialize_u64(self, v: u64) -> Written { + Ok(v.to_string()) + } + fn serialize_u128(self, v: u128) -> Written { + Ok(v.to_string()) + } + fn serialize_f32(self, _: f32) -> Written { + Err(refuse("a map key must be a string")) + } + fn serialize_f64(self, _: f64) -> Written { + Err(refuse("a map key must be a string")) + } + fn serialize_char(self, v: char) -> Written { + Ok(v.to_string()) + } + fn serialize_str(self, v: &str) -> Written { + Ok(v.to_owned()) + } + fn serialize_bytes(self, _: &[u8]) -> Written { + Err(refuse("a map key must be a string")) + } + fn serialize_none(self) -> Written { + Err(refuse("a map key must be a string")) + } + fn serialize_some(self, _: &T) -> Written { + Err(refuse("a map key must be a string")) + } + fn serialize_unit(self) -> Written { + Err(refuse("a map key must be a string")) + } + fn serialize_unit_struct(self, _: &'static str) -> Written { + Err(refuse("a map key must be a string")) + } + fn serialize_unit_variant(self, _: &'static str, _: u32, variant: &'static str) -> Written { + Ok(variant.to_owned()) + } + fn serialize_newtype_struct(self, _: &'static str, value: &T) -> Written { + value.serialize(self) + } + fn serialize_newtype_variant(self, _: &'static str, _: u32, _: &'static str, _: &T) -> Written { + Err(refuse("a map key must be a string")) + } + fn serialize_seq(self, _: Option) -> Written { + Err(refuse("a map key must be a string")) + } + fn serialize_tuple(self, _: usize) -> Written { + Err(refuse("a map key must be a string")) + } + fn serialize_tuple_struct(self, _: &'static str, _: usize) -> Written { + Err(refuse("a map key must be a string")) + } + fn serialize_tuple_variant(self, _: &'static str, _: u32, _: &'static str, _: usize) -> Written { + Err(refuse("a map key must be a string")) + } + fn serialize_map(self, _: Option) -> Written { + Err(refuse("a map key must be a string")) + } + fn serialize_struct(self, _: &'static str, _: usize) -> Written { + Err(refuse("a map key must be a string")) + } + fn serialize_struct_variant(self, _: &'static str, _: u32, _: &'static str, _: usize) -> Written { + Err(refuse("a map key must be a string")) + } +} + +impl<'w, 'a> serde::Serializer for Ser<'w, 'a> { + type Ok = (); + type Error = WriteError; + type SerializeSeq = Array<'w, 'a>; + type SerializeTuple = Array<'w, 'a>; + type SerializeTupleStruct = Array<'w, 'a>; + type SerializeTupleVariant = Array<'w, 'a>; + type SerializeMap = Object<'w, 'a>; + type SerializeStruct = Object<'w, 'a>; + type SerializeStructVariant = Object<'w, 'a>; + + fn serialize_bool(self, v: bool) -> Written { + self.w.start(self.depth, if v { 2 } else { 1 }) + } + fn serialize_i8(self, v: i8) -> Written { + self.w.signed(self.depth, v.into()) + } + fn serialize_i16(self, v: i16) -> Written { + self.w.signed(self.depth, v.into()) + } + fn serialize_i32(self, v: i32) -> Written { + self.w.signed(self.depth, v.into()) + } + fn serialize_i64(self, v: i64) -> Written { + self.w.signed(self.depth, v) + } + fn serialize_i128(self, v: i128) -> Written { + match (u64::try_from(v), i64::try_from(v)) { + (Ok(u), _) => self.w.unsigned(self.depth, u), + (_, Ok(i)) => self.w.signed(self.depth, i), + _ => Err(refuse("number out of range")), + } + } + fn serialize_u8(self, v: u8) -> Written { + self.w.unsigned(self.depth, v.into()) + } + fn serialize_u16(self, v: u16) -> Written { + self.w.unsigned(self.depth, v.into()) + } + fn serialize_u32(self, v: u32) -> Written { + self.w.unsigned(self.depth, v.into()) + } + fn serialize_u64(self, v: u64) -> Written { + self.w.unsigned(self.depth, v) + } + fn serialize_u128(self, v: u128) -> Written { + self.w.unsigned(self.depth, u64::try_from(v).map_err(|_| refuse("number out of range"))?) + } + fn serialize_f32(self, v: f32) -> Written { + self.w.float(self.depth, v.into()) + } + fn serialize_f64(self, v: f64) -> Written { + self.w.float(self.depth, v) + } + fn serialize_char(self, v: char) -> Written { + self.w.string(self.depth, v.encode_utf8(&mut [0; 4])) + } + fn serialize_str(self, v: &str) -> Written { + self.w.string(self.depth, v) + } + fn serialize_bytes(self, v: &[u8]) -> Written { + let mut a = self.array()?; + for b in v { + a.item(b)?; + } + a.close() + } + fn serialize_none(self) -> Written { + self.w.start(self.depth, 0) + } + fn serialize_some(self, value: &T) -> Written { + value.serialize(self) + } + fn serialize_unit(self) -> Written { + self.w.start(self.depth, 0) + } + fn serialize_unit_struct(self, _: &'static str) -> Written { + self.w.start(self.depth, 0) + } + fn serialize_unit_variant(self, _: &'static str, _: u32, variant: &'static str) -> Written { + self.w.string(self.depth, variant) + } + fn serialize_newtype_struct(self, _: &'static str, value: &T) -> Written { + value.serialize(self) + } + fn serialize_newtype_variant(self, _: &'static str, _: u32, variant: &'static str, value: &T) -> Written { + value.serialize(self.variant(variant)?) + } + fn serialize_seq(self, _: Option) -> Written> { + self.array() + } + fn serialize_tuple(self, _: usize) -> Written> { + self.array() + } + fn serialize_tuple_struct(self, _: &'static str, _: usize) -> Written> { + self.array() + } + fn serialize_tuple_variant(self, _: &'static str, _: u32, variant: &'static str, _: usize) -> Written> { + self.variant(variant)?.array() + } + fn serialize_map(self, _: Option) -> Written> { + self.object() + } + fn serialize_struct(self, _: &'static str, _: usize) -> Written> { + self.object() + } + fn serialize_struct_variant(self, _: &'static str, _: u32, variant: &'static str, _: usize) -> Written> { + self.variant(variant)?.object() + } +} + +impl serde::ser::SerializeSeq for Array<'_, '_> { + type Ok = (); + type Error = WriteError; + fn serialize_element(&mut self, value: &T) -> Written { + self.item(value) + } + fn end(self) -> Written { + self.close() + } +} + +impl serde::ser::SerializeTuple for Array<'_, '_> { + type Ok = (); + type Error = WriteError; + fn serialize_element(&mut self, value: &T) -> Written { + self.item(value) + } + fn end(self) -> Written { + self.close() + } +} + +impl serde::ser::SerializeTupleStruct for Array<'_, '_> { + type Ok = (); + type Error = WriteError; + fn serialize_field(&mut self, value: &T) -> Written { + self.item(value) + } + fn end(self) -> Written { + self.close() + } +} + +impl serde::ser::SerializeTupleVariant for Array<'_, '_> { + type Ok = (); + type Error = WriteError; + fn serialize_field(&mut self, value: &T) -> Written { + self.item(value) + } + fn end(self) -> Written { + self.close() + } +} + +impl serde::ser::SerializeMap for Object<'_, '_> { + type Ok = (); + type Error = WriteError; + fn serialize_key(&mut self, key: &T) -> Written { + let key = key.serialize(Key)?; + self.key(key) + } + fn serialize_value(&mut self, value: &T) -> Written { + self.value(value) + } + fn end(self) -> Written { + self.close() + } +} + +impl serde::ser::SerializeStruct for Object<'_, '_> { + type Ok = (); + type Error = WriteError; + fn serialize_field(&mut self, key: &'static str, value: &T) -> Written { + self.entry(key, value) + } + fn end(self) -> Written { + self.close() + } +} + +impl serde::ser::SerializeStructVariant for Object<'_, '_> { + type Ok = (); + type Error = WriteError; + fn serialize_field(&mut self, key: &'static str, value: &T) -> Written { + self.entry(key, value) + } + fn end(self) -> Written { + self.close() + } +} diff --git a/crates/kernel/src/prism_measure.rs b/crates/kernel/src/prism_measure.rs index 41036f34b..3c5b5de0b 100644 --- a/crates/kernel/src/prism_measure.rs +++ b/crates/kernel/src/prism_measure.rs @@ -637,6 +637,54 @@ pub fn certified_prism_equivalent(a: &crate::Body, b: &crate::Body) -> crate::Re }) } +/// A uniform prism along a plane's normal, read off a body's record: its levels above the plane +/// and its section in the plane's coordinates. +#[derive(Clone, Debug, PartialEq)] +pub struct PrismSection { + /// The levels of its bottom and its top cap above the plane (`lo < hi`). + pub lo: f64, + pub hi: f64, + /// Its section, exact: lines and arcs, the outer loop counter-clockwise, the holes clockwise. + pub region: solidcraft_geom::Region2, + /// How far the levels may be off the body's caps (the caps' vertices lie within it of them). + pub tolerance: f64, +} + +/// The uniform prism `body` is along `plane`'s normal, when its record proves it one: two caps +/// square to the normal, every other face a wall running straight between them along the +/// normal and standing on both caps' edges, the two caps one section (see [`certified_prism_equivalent`] +/// for the profiles it proves: a convex straight outline or a circle, with separate round +/// holes). The body's current geometry, not how it was made: a tool trimmed by a boolean that +/// left it a prism is one. `None` when that is not proved. +pub fn certified_prism_section(body: &crate::Body, plane: &Plane) -> crate::Result> { + crate::guard("certified prism section", || { + if body.is_mesh() || !body.size().is_finite() { + return Ok(None); + } + let record = crate::native::brep_record(body)?; + let tol = body.size().max(1.) * 1e-10; + let Some(c) = certificate(&record, body.size(), plane, tol) else { return Ok(None) }; + let mut outer = None; + let mut holes = Vec::new(); + for lp in c.loops { + let positive = lp.area.lo > 0.; + let lp = solidcraft_geom::Loop2 { segs: lp.segments.into_vec() }; + if positive { + if outer.replace(lp).is_some() { + return Ok(None); + } + } else { + holes.push(lp); + } + } + let Some(outer) = outer else { return Ok(None) }; + // The caps' vertices are within twice the tolerance of their levels (`certificate`), and + // the levels are worked out from the plane's origin. + let tolerance = 2. * tol + 128. * f64::EPSILON * (plane.origin.len() + c.lo.abs() + c.hi.abs()).max(1.); + Ok(Some(PrismSection { lo: c.lo, hi: c.hi, region: solidcraft_geom::Region2 { outer, holes }, tolerance })) + }) +} + /// [`certified_prism_equivalent`] of the records `a` and `b` of bodies of sizes `size_a` and /// `size_b`. fn equivalent(a: &Brep, size_a: f64, b: &Brep, size_b: f64) -> Option { @@ -823,6 +871,31 @@ mod tests { r.faces.iter().position(|f| plane_of(&f.surface).is_none()).unwrap() } + /// A 10 x 10 tool from z = 0 cut by a pin of radius 2 standing through it, joined to a plate + /// at z 1 ... 2 (a To Object tool trimmed by its curved target): the lump under the plate is + /// a prism from 0 to 1 whose section is the square less the pin's circle, 100 - 4π; the lump + /// above it steps (the pin stands up through it) and is no prism. + #[test] + fn a_trimmed_tool_reads_as_the_prism_of_its_current_section() { + use solidcraft_geom::{Loop2, Region2}; + let pin = crate::cylinder(Vec3::new(25., 25., 0.), Vec3::Z, 2., 20.).unwrap(); + let stop = crate::box_solid(Vec3::new(19., 19., 1.), Vec3::new(31., 31., 2.)).unwrap(); + let roof = crate::boolean(&pin, &stop, crate::BoolOp::Union).unwrap().unwrap(); + let square = + Region2 { outer: Loop2::polygon(&[Vec2::new(20., 20.), Vec2::new(30., 20.), Vec2::new(30., 30.), Vec2::new(20., 30.)]), holes: vec![] }; + let tool = crate::extrude(&Plane::XY, &[square], 0., 25.).unwrap().remove(0); + let lumps = crate::boolean(&tool, &roof, crate::BoolOp::Cut).unwrap().unwrap().lumps().unwrap(); + assert_eq!(lumps.len(), 2); + let sections: Vec> = lumps.iter().map(|l| certified_prism_section(l, &Plane::XY).unwrap()).collect(); + let lower = sections.iter().flatten().collect::>(); + assert_eq!(lower.len(), 1, "only the lump under the plate is a prism"); + let lower = lower[0]; + assert!(lower.lo.abs() <= lower.tolerance && (lower.hi - 1.).abs() <= lower.tolerance, "{} … {}", lower.lo, lower.hi); + assert_eq!(lower.region.holes.len(), 1); + assert!(lower.region.outer.signed_area() > 0. && lower.region.holes[0].signed_area() < 0.); + assert!((lower.region.area() - (100. - 4. * std::f64::consts::PI)).abs() < 1e-8, "{}", lower.region.area()); + } + #[test] fn actual_drilled_prism_and_step_reopen_are_certified_without_history() { let source = drilled(6., 0.);