Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

Drawings: first landing from the drawings branch (#8249)

bherbruck9bcb2ffe6819
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index d47d45eb55..0027e664a0 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -268,7 +268,9 @@ a conflict. `crates/doc/src/format/pending/README.md` has an example.
**At release time** the maintainer runs `scripts/fold-format-pending.sh`, which moves the pending
files into `crates/doc/src/format/v<N>/` and fixes that number for good (see
-[docs/releasing.md](docs/releasing.md)). Never add a file to a `v<N>/` folder afterwards.
+[docs/releasing.md](docs/releasing.md)). Never add a file to a `v<N>/` folder afterwards. Drawings
+follow the same rules with their own numbers, from 1, in `crates/doc/src/drawing/format/` (see its
+`pending/README.md`), and the same script folds them.
## Lists many changes add to
diff --git a/crates/doc/build.rs b/crates/doc/build.rs
index 18bea3206b..3179af80bc 100644
--- a/crates/doc/build.rs
+++ b/crates/doc/build.rs
@@ -1,15 +1,40 @@
-//! Lists the design-format changes in `src/format/`: one file per change, in `v<N>/` once a
-//! release fixed its number, else in `pending/` (see `src/format/pending/README.md`). The list is
+//! Lists the format changes of each family of files versioned by `src/format.rs`: designs in
+//! `src/format/`, drawings in `src/drawing/format/` (#3890). One file per change, in `v<N>/` once a
+//! release fixed its number, else in `pending/` (see `src/format/pending/README.md`). The lists are
//! generated so that a change adds a file and never edits a line another change also edits.
use std::fmt::Write as _;
use std::path::{Path, PathBuf};
-/// The last format whose upgrade steps are written out in `format.rs` (`JSON_STEPS`).
-const HAND_WRITTEN: u32 = 22;
+/// A family's change files: their folder, the last format before them, and the prefix of the
+/// family's lists in `format.rs`.
+struct Family {
+ folder: &'static str,
+ base: u32,
+ list_prefix: &'static str,
+}
+
+/// Every family, each read by `scripts/fold-format-pending.sh` too. A design's upgrade steps are
+/// written out in `format.rs` up to 22 (`JSON_STEPS`); a drawing's first format is 1.
+const FAMILIES: [Family; 2] =
+ [Family { folder: "src/format", base: 22, list_prefix: "" }, Family { folder: "src/drawing/format", base: 1, list_prefix: "DRAWING_" }];
fn main() {
- let root = PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap()).join("src/format");
+ let manifest = PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap());
+ let mut out = String::new();
+ let mut mods = String::new();
+ for family in &FAMILIES {
+ lists(family, &manifest, &mut out, &mut mods);
+ }
+ out.push_str(&mods);
+ let dest = PathBuf::from(std::env::var("OUT_DIR").unwrap()).join("format_parts.rs");
+ std::fs::write(dest, out).unwrap();
+}
+
+/// A family's `FOLDED` and `PENDING` lists; its folded formats follow on from its base.
+fn lists(family: &Family, manifest: &Path, out: &mut String, mods: &mut String) {
+ let Family { folder, base, list_prefix } = family;
+ let root = manifest.join(folder);
println!("cargo:rerun-if-changed={}", root.display());
let mut folded: Vec<(u32, PathBuf)> = std::fs::read_dir(&root)
.unwrap_or_else(|e| panic!("{}: {e}", root.display()))
@@ -21,23 +46,24 @@ fn main() {
.collect();
folded.sort();
for (i, (version, _)) in folded.iter().enumerate() {
- let expected = HAND_WRITTEN + 1 + i as u32;
- assert_eq!(*version, expected, "src/format/: expected v{expected}/ next, found v{version}/ (versions are contiguous)");
+ let expected = base + 1 + i as u32;
+ assert_eq!(*version, expected, "{folder}/: expected v{expected}/ next, found v{version}/ (versions are contiguous)");
}
- let mut out = String::new();
- let mut mods = String::new();
- out.push_str("/// The changes of each format after the hand-written ones, oldest first.\nconst FOLDED: &[(u32, &[Part])] = &[\n");
+ // Module names start with the family's (`drawing_pending_…`), so two families' changes of one
+ // name never clash.
+ let module = list_prefix.to_ascii_lowercase();
+ let _ = writeln!(
+ out,
+ "/// The changes of each format after the base, oldest first (`{folder}/v<N>/`).\nconst {list_prefix}FOLDED: &[(u32, &[Part])] = &["
+ );
for (version, dir) in &folded {
let _ = writeln!(out, " ({version}, &[");
- parts(dir, &format!("v{version}"), &mut out, &mut mods);
+ parts(dir, &format!("{module}v{version}"), out, mods);
out.push_str(" ]),\n");
}
- out.push_str("];\n\n/// The changes no release has a number for yet (`src/format/pending/`).\nconst PENDING: &[Part] = &[\n");
- parts(&root.join("pending"), "pending", &mut out, &mut mods);
- out.push_str("];\n");
- out.push_str(&mods);
- let dest = PathBuf::from(std::env::var("OUT_DIR").unwrap()).join("format_parts.rs");
- std::fs::write(dest, out).unwrap();
+ let _ = writeln!(out, "];\n\n/// The changes no release has a number for yet (`{folder}/pending/`).\nconst {list_prefix}PENDING: &[Part] = &[");
+ parts(&root.join("pending"), &format!("{module}pending"), out, mods);
+ out.push_str("];\n\n");
}
/// The `Part`s of the change files in `dir`, in file-name order, and a module for each.
diff --git a/crates/doc/src/assembly.rs b/crates/doc/src/assembly.rs
index 0ca382f854..7775f2afe9 100644
--- a/crates/doc/src/assembly.rs
+++ b/crates/doc/src/assembly.rs
@@ -124,6 +124,48 @@ fn identity() -> Mat {
IDENTITY
}
+/// How a component counts in the bill of materials of an assembly it is placed in. It is a part
+/// property (the `bom_type` key of the component's [`Metadata`](crate::Metadata)); a component
+/// without one is [`BomType::Normal`].
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum BomType {
+ /// A row of its own; every occurrence adds to its quantity.
+ #[default]
+ Normal,
+ /// No row of its own: what it holds counts as if placed directly in its parent.
+ Phantom,
+ /// Shown, but counted nowhere, and nothing inside it is counted either.
+ Reference,
+ /// Bought: one row, with nothing inside it counted or listed.
+ Purchased,
+ /// Made as one item that doesn't come apart (a welded frame): one row in the assembly it is
+ /// placed in. What it holds is listed in its own bill of materials, and its purchased parts
+ /// also in the parts-only list of the assembly it is placed in.
+ Inseparable,
+}
+
+impl BomType {
+ /// Every type, in the order commands and documentation list them.
+ pub const ALL: [BomType; 5] = [BomType::Normal, BomType::Phantom, BomType::Reference, BomType::Purchased, BomType::Inseparable];
+
+ /// The word the design file and commands use.
+ pub fn as_str(self) -> &'static str {
+ match self {
+ BomType::Normal => "normal",
+ BomType::Phantom => "phantom",
+ BomType::Reference => "reference",
+ BomType::Purchased => "purchased",
+ BomType::Inseparable => "inseparable",
+ }
+ }
+
+ /// The type a word names, if it names one.
+ pub fn parse(word: &str) -> Option<BomType> {
+ BomType::ALL.into_iter().find(|t| t.as_str() == word)
+ }
+}
+
/// How deep and how many placements [`Document::placements`] walks.
pub const MAX_PLACEMENT_DEPTH: usize = 64;
pub const MAX_PLACEMENTS: usize = 100_000;
diff --git a/crates/doc/src/drawing.rs b/crates/doc/src/drawing.rs
new file mode 100644
index 0000000000..2c7dfb4b95
--- /dev/null
+++ b/crates/doc/src/drawing.rs
@@ -0,0 +1,305 @@
+//! A drawing (#3890): sheets of paper that draw designs saved in their own files. A drawing is a
+//! file of its own, `"format": "solidcraft-drawing/N"`, versioned by the same code as designs
+//! ([`DRAWING`]); format 1 is this record.
+//!
+//! - **Sources** are the designs it draws: an id and the design file's path, relative to the
+//! drawing's folder once the drawing is saved, else as given, with `/` between folders (a linked
+//! design's [`DesignLink`](crate::DesignLink) rule). What a design was when the drawing last saw
+//! it is not saved here.
+//! - **Sheets**: the paper, a copy of its drawing border, the resolution its pictures are rendered
+//! at, the component it documents, and whether it is left out of the sheet count or of printing.
+//! The border is a copy of the profile it was made with, never a name, so a later built-in never
+//! changes a saved drawing.
+//! - **Units** follow each view's design or are one length unit for the whole drawing. The
+//! **language** is the content's, a BCP 47 tag chosen when the drawing is made, whatever the
+//! interface's is. **Properties** follow [`Metadata`]'s rules.
+//!
+//! The rules, which every later kind of record (views, annotations, tables) keeps too:
+//! - Every object has an id of [`crate::ids`]: random, so objects added side by side never take
+//! the same one, and written as 13 characters of base32. No two objects share an id, and a run
+//! never gives a removed object's id again ([`Drawing::allocate_id`]).
+//! - Every reference between records is an id and must resolve: a file with one that doesn't is
+//! damaged and refused, never patched.
+//! - 1 to [`MAX_SHEETS`] sheets and at most [`MAX_SOURCES`] sources; names of 1 to
+//! [`MAX_NAME_BYTES`] bytes; paths of 1 to [`MAX_PATH_BYTES`] bytes, without NUL.
+//! - Nothing derived is saved, and a drawing always saves as the same bytes: fields in their
+//! order, maps sorted.
+//! - A later change to the record is one file in `src/drawing/format/pending/` (its README).
+//!
+//! [`Drawing::from_json`] reads a file in this order: at most [`MAX_DRAWING_BYTES`] of text, the
+//! family's format check, every number in range, the upgrade, the typed record, then
+//! [`Drawing::validate`].
+
+use std::collections::BTreeSet;
+use std::sync::Arc;
+
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use solidcraft_geom::drawing_sheet::{self, DrawingBorderProfile};
+
+use crate::format::DRAWING;
+use crate::ids::{self, IdSource};
+use crate::{DocError, Metadata, Result, expr};
+
+/// The most sheets a drawing may have.
+pub const MAX_SHEETS: usize = 1000;
+/// The most designs a drawing may draw.
+pub const MAX_SOURCES: usize = 64;
+/// The longest name of a drawing or a sheet, in bytes.
+pub const MAX_NAME_BYTES: usize = 256;
+/// The longest path to a design, in bytes.
+pub const MAX_PATH_BYTES: usize = 4096;
+/// The longest language tag: what RFC 5646 asks every reader to take (§4.4.1).
+pub const MAX_LANGUAGE_CHARS: usize = 35;
+/// The largest drawing read, as JSON text.
+pub const MAX_DRAWING_BYTES: usize = 16 << 20;
+/// The resolution a sheet's pictures (its shaded views) are rendered at unless it says, in dots
+/// per inch.
+pub const DEFAULT_DPI: f64 = 300.0;
+/// The lowest resolution a sheet may ask for.
+pub const MIN_DPI: f64 = 25.0;
+/// The highest resolution a sheet may ask for.
+pub const MAX_DPI: f64 = 2400.0;
+
+/// A drawing: its sheets and the designs they draw.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct Drawing {
+ /// `solidcraft-drawing/N`: the format this build writes, whatever the file said.
+ pub format: String,
+ /// The changes of `format` this drawing has while they are pending
+ /// ([`Family::pending_names`](crate::format::Family::pending_names)). Empty, and not saved,
+ /// otherwise.
+ #[serde(default, skip_serializing_if = "Vec::is_empty")]
+ pub format_pending: Vec<String>,
+ pub name: String,
+ /// The designs the drawing draws.
+ pub sources: Vec<Source>,
+ /// The drawing's properties and other tools' data, kept as they are.
+ #[serde(default, skip_serializing_if = "Metadata::is_empty")]
+ pub properties: Metadata,
+ #[serde(default)]
+ pub units: Units,
+ /// The language of the drawing's content, a BCP 47 tag (`en-GB`).
+ pub language: String,
+ /// In order, each behind its own `Arc`, so an undo step shares every sheet it didn't change.
+ pub sheets: Vec<Arc<Sheet>>,
+}
+
+/// A design the drawing draws.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct Source {
+ #[serde(with = "crate::ids")]
+ pub id: u64,
+ /// The design file: relative to the drawing's folder once the drawing is saved, else as given
+ /// (`/` separates folders).
+ pub path: String,
+}
+
+/// The length unit a drawing gives its measurements in.
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case", deny_unknown_fields)]
+pub enum Units {
+ /// Each view's design's own units.
+ #[default]
+ FollowModel,
+ /// One length unit for the whole drawing, by its name in [`expr::UNITS`] (`mm`, `in`).
+ Fixed { unit: String },
+}
+
+/// One sheet of a drawing.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct Sheet {
+ #[serde(with = "crate::ids")]
+ pub id: u64,
+ pub name: String,
+ /// The paper: its size and the way it lies.
+ pub sheet: drawing_sheet::Sheet,
+ /// A copy of the drawing border's profile (`None`: no drawing border).
+ pub border: Option<DrawingBorderProfile>,
+ /// The resolution its pictures (its shaded views) are rendered at, in dots per inch.
+ #[serde(default = "default_dpi")]
+ pub dpi: f64,
+ /// The component the sheet documents, which its title block reads.
+ pub documents: Option<SheetComponent>,
+ #[serde(default)]
+ pub excluded: Excluded,
+}
+
+/// A component of one of the drawing's designs.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct SheetComponent {
+ /// The [`Source`]'s id.
+ #[serde(with = "crate::ids")]
+ pub source: u64,
+ /// The component's id in that design, as the design writes it (0: the design itself).
+ pub component: u64,
+}
+
+/// What a sheet is left out of.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(default, deny_unknown_fields)]
+pub struct Excluded {
+ /// The sheet count ("sheet 2 of 3" on the other sheets).
+ pub count: bool,
+ /// Printing and exporting every sheet.
+ pub print: bool,
+}
+
+fn default_dpi() -> f64 {
+ DEFAULT_DPI
+}
+
+impl Drawing {
+ /// A drawing of no designs yet, named `name` and written in `language`, with one sheet named
+ /// `sheet`: the paper `paper` with a copy of `border`, its id from `id_source`.
+ pub fn new(
+ name: &str,
+ language: &str,
+ sheet: &str,
+ paper: drawing_sheet::Sheet,
+ border: Option<DrawingBorderProfile>,
+ id_source: &mut IdSource,
+ ) -> Result<Drawing> {
+ let id = id_source.next(&BTreeSet::new())?;
+ let first = Sheet { id, name: sheet.into(), sheet: paper, border, dpi: DEFAULT_DPI, documents: None, excluded: Excluded::default() };
+ let drawing = Drawing {
+ format: DRAWING.format_string(DRAWING.current()),
+ format_pending: DRAWING.pending_names(),
+ name: name.into(),
+ sources: Vec::new(),
+ properties: Metadata::default(),
+ units: Units::default(),
+ language: language.into(),
+ sheets: vec![Arc::new(first)],
+ };
+ drawing.validate()?;
+ Ok(drawing)
+ }
+
+ /// Read a drawing file's JSON (any format this build knows; older ones are upgraded). A file
+ /// that breaks a rule of the record is damaged and refused, never patched.
+ pub fn from_json(s: &str) -> Result<Drawing> {
+ if s.len() > MAX_DRAWING_BYTES {
+ return Err(DocError::Invalid(format!("drawing too large (at most {} MiB)", MAX_DRAWING_BYTES >> 20)));
+ }
+ let mut v: Value = serde_json::from_str(s).map_err(|e| DocError::Invalid(format!("not a SolidCraft drawing: {e}")))?;
+ let (version, applied) = DRAWING.take_version(&mut v)?;
+ DRAWING.check_numbers(&v, "properties")?;
+ DRAWING.upgrade(&mut v, version, applied.as_deref())?;
+ let d: Drawing = serde_json::from_value(v).map_err(damaged)?;
+ d.validate().map_err(damaged)?;
+ Ok(Drawing { format: DRAWING.format_string(DRAWING.current()), format_pending: DRAWING.pending_names(), ..d })
+ }
+
+ /// The drawing's JSON: the same bytes for the same drawing. JSON longer than a read takes
+ /// ([`MAX_DRAWING_BYTES`]) is refused, so every drawing saved opens again: other tools'
+ /// properties are kept as they came, and indenting them can make a drawing that read in
+ /// under the limit save over it.
+ pub fn to_json(&self) -> Result<String> {
+ let text = serde_json::to_string_pretty(self).map_err(|e| DocError::Invalid(format!("drawing not saved: {e}")))?;
+ require(text.len() <= MAX_DRAWING_BYTES, || format!("drawing too large to save (at most {} MiB)", MAX_DRAWING_BYTES >> 20))?;
+ Ok(text)
+ }
+
+ /// An id for a new object: one no object of the drawing has, from `id_source`, which never
+ /// gives one twice.
+ pub fn allocate_id(&self, id_source: &mut IdSource) -> Result<u64> {
+ id_source.next(&self.ids().collect())
+ }
+
+ /// Every object's id, of every kind: what a new id must differ from. Each later kind adds its
+ /// own here.
+ fn ids(&self) -> impl Iterator<Item = u64> {
+ self.sources.iter().map(|s| s.id).chain(self.sheets.iter().map(|s| s.id))
+ }
+
+ /// The record's rules (the module's notes): what reading a file checks, and what every edit
+ /// keeps.
+ pub fn validate(&self) -> Result<()> {
+ require((1..=MAX_SHEETS).contains(&self.sheets.len()), || format!("a drawing has 1 to {MAX_SHEETS} sheets"))?;
+ require(self.sources.len() <= MAX_SOURCES, || format!("a drawing draws at most {MAX_SOURCES} designs"))?;
+ check_name(&self.name, "the drawing's")?;
+ require(is_language_tag(&self.language), || {
+ format!("the language is not a BCP 47 tag of 2 to {MAX_LANGUAGE_CHARS} characters (such as `en` or `en-GB`)")
+ })?;
+ if let Units::Fixed { unit } = &self.units {
+ // A length unit of the expression unit table, written as the table writes it.
+ let length = unit.trim() == unit.as_str() && expr::unit_info(unit).is_some_and(|(kind, _)| kind == expr::Kind::Length);
+ require(length, || "the drawing's unit is not a length unit (such as `mm` or `in`)".into())?;
+ }
+ let mut seen = BTreeSet::new();
+ for id in self.ids() {
+ require(id != 0, || "an object has the id 0, which is never one".into())?;
+ require(seen.insert(id), || format!("two objects have the id {}", ids::encode(id)))?;
+ }
+ for source in &self.sources {
+ let path = &source.path;
+ require(!path.is_empty() && path.len() <= MAX_PATH_BYTES && !path.contains('\0'), || {
+ format!("source {}: a design's path is 1 to {MAX_PATH_BYTES} bytes, without NUL", ids::encode(source.id))
+ })?;
+ }
+ for sheet in &self.sheets {
+ self.check_sheet(sheet).map_err(|e| DocError::Invalid(format!("sheet {}: {e}", ids::encode(sheet.id))))?;
+ }
+ Ok(())
+ }
+
+ /// A sheet's own rules, and that the source it documents is one of the drawing's.
+ fn check_sheet(&self, sheet: &Sheet) -> Result<()> {
+ check_name(&sheet.name, "its")?;
+ sheet.sheet.size_mm().map_err(from_sheet)?;
+ if let Some(border) = &sheet.border {
+ border.validate().map_err(from_sheet)?;
+ }
+ require((MIN_DPI..=MAX_DPI).contains(&sheet.dpi), || format!("its pictures are {MIN_DPI} to {MAX_DPI} dpi"))?;
+ match sheet.documents {
+ Some(SheetComponent { source, .. }) => {
+ let named = || format!("it documents source {}, which the drawing doesn't have", ids::encode(source));
+ require(self.sources.iter().any(|s| s.id == source), named)
+ }
+ None => Ok(()),
+ }
+ }
+}
+
+/// `Ok` when `ok`, else the rule `broken` names.
+fn require(ok: bool, broken: impl FnOnce() -> String) -> Result<()> {
+ if ok { Ok(()) } else { Err(DocError::Invalid(broken())) }
+}
+
+/// A name: 1 to [`MAX_NAME_BYTES`] bytes, not only spaces, without control characters.
+fn check_name(name: &str, whose: &str) -> Result<()> {
+ require(!name.trim().is_empty() && name.len() <= MAX_NAME_BYTES && !name.chars().any(char::is_control), || {
+ format!("{whose} name is 1 to {MAX_NAME_BYTES} bytes, not only spaces, without control characters")
+ })
+}
+
+/// A well-formed language tag, as far as a drawing needs (RFC 5646 §2.1): 2 to
+/// [`MAX_LANGUAGE_CHARS`] characters, subtags of 1 to 8 ASCII letters and digits joined by `-`,
+/// the first of 2 to 8 letters (`en`, `en-GB`, `zh-Hans-CN`). Whether the subtags are registered
+/// isn't checked, and a private-use tag alone (`x-…`) isn't taken.
+fn is_language_tag(tag: &str) -> bool {
+ let mut subtags = tag.split('-');
+ let first = subtags.next().unwrap_or_default();
+ (2..=MAX_LANGUAGE_CHARS).contains(&tag.len())
+ && (2..=8).contains(&first.len())
+ && first.bytes().all(|b| b.is_ascii_alphabetic())
+ && subtags.all(|s| (1..=8).contains(&s.len()) && s.bytes().all(|b| b.is_ascii_alphanumeric()))
+}
+
+/// A file that breaks a rule of the record.
+fn damaged(e: impl std::fmt::Display) -> DocError {
+ DocError::Invalid(format!("damaged drawing: {e}"))
+}
+
+fn from_sheet(e: drawing_sheet::Invalid) -> DocError {
+ DocError::Invalid(e.to_string())
+}
+
+#[cfg(test)]
+#[path = "drawing_tests.rs"]
+mod tests;
diff --git a/crates/doc/src/drawing/format/pending/README.md b/crates/doc/src/drawing/format/pending/README.md
new file mode 100644
index 0000000000..29e16f40fc
--- /dev/null
+++ b/crates/doc/src/drawing/format/pending/README.md
@@ -0,0 +1,30 @@
+# Pending drawing-format changes
+
+One file per change to what a drawing file saves that no release has shipped yet. Drawings
+(`"format": "solidcraft-drawing/N"`, #3890) are versioned by the same code as designs
+(`crates/doc/src/format.rs`, `Family`), from their own first format, 1. Adding a file here is the
+whole format bump: never edit the `DRAWING` family in `format.rs`, another change's file or a
+`../v<N>/` folder.
+
+- Name it after the change, lowercase with dashes: `sheet-views.rs`.
+- Start it with a `//!` note: what is saved, what an older drawing gets without it, and what
+ the last release does with a drawing that has it (it refuses the newer format number).
+- If older drawings must be rewritten as they open, add the step to the same file:
+
+ ```rust
+ //! …the note…
+ use serde_json::Value;
+
+ pub fn step(v: &mut Value) -> crate::Result<()> {
+ // rewrite the drawing's JSON here
+ Ok(())
+ }
+ ```
+
+ Steps run in file-name order, after the steps of every older format.
+
+While this folder has a change in it, the build writes the next drawing format number (the last
+folded one + 1, which no release reads), and lists the changes a drawing has in its
+`format_pending` field, so a later build applies only the steps that drawing is missing. At
+release time `scripts/fold-format-pending.sh` moves these files into `../v<N>/`, as it does the
+design format's (`crates/doc/src/format/pending/README.md`).
diff --git a/crates/doc/src/drawing_tests.rs b/crates/doc/src/drawing_tests.rs
new file mode 100644
index 0000000000..d51e8fd274
--- /dev/null
+++ b/crates/doc/src/drawing_tests.rs
@@ -0,0 +1,553 @@
+use serde_json::json;
+use solidcraft_geom::drawing_sheet::{Margins, Orientation, PaperSize, SheetSize};
+
+use super::*;
+
+/// The seed every test drawing's ids come from.
+const SEED: u64 = 3890;
+
+/// A profile of its own: ISO 5457's filing margin and trimming marks, which the built-in leaves off.
+fn own_border() -> DrawingBorderProfile {
+ DrawingBorderProfile { filing_margin: true, trimming_mark_mm: Some([10.0, 5.0]), ..DrawingBorderProfile::iso() }
+}
+
+/// Three designs on two sheets: the first sheet (A3, the ISO border) documents component 7 of the
+/// first design; the second (A4 portrait, a border of its own, 600 dpi, left out of printing)
+/// documents the second design. The third design is on no sheet yet.
+fn plate() -> Drawing {
+ let mut id_source = IdSource::seeded(SEED);
+ let a3 = drawing_sheet::Sheet::standard(PaperSize::A3, Orientation::Landscape);
+ let mut d = Drawing::new("Plate assembly", "en-GB", "Assembly", a3, Some(DrawingBorderProfile::iso()), &mut id_source).unwrap();
+ for path in ["plate.sc", "../parts/bolt.sc", "bracket.sc"] {
+ let id = d.allocate_id(&mut id_source).unwrap();
+ d.sources.push(Source { id, path: path.into() });
+ }
+ let (plate_id, bolt_id) = (d.sources[0].id, d.sources[1].id);
+ let id = d.allocate_id(&mut id_source).unwrap();
+ d.sheets.push(Arc::new(Sheet {
+ id,
+ name: "Bolt".into(),
+ sheet: drawing_sheet::Sheet::standard(PaperSize::A4, Orientation::Portrait),
+ border: Some(own_border()),
+ dpi: 600.0,
+ documents: Some(SheetComponent { source: bolt_id, component: 0 }),
+ excluded: Excluded { count: false, print: true },
+ }));
+ Arc::make_mut(&mut d.sheets[0]).documents = Some(SheetComponent { source: plate_id, component: 7 });
+ d.properties.set(crate::metadata::Owner::Design, "author", json!("Jane Doe")).unwrap();
+ d.units = Units::Fixed { unit: "in".into() };
+ d.validate().unwrap();
+ d
+}
+
+/// One A4 sheet that documents nothing, no sources: the base the caps grow from.
+fn bare() -> Drawing {
+ let a4 = drawing_sheet::Sheet::standard(PaperSize::A4, Orientation::Landscape);
+ Drawing::new("Bare", "en", "Sheet", a4, None, &mut IdSource::seeded(SEED)).unwrap()
+}
+
+fn file(d: &Drawing) -> Value {
+ serde_json::from_str(&d.to_json().unwrap()).unwrap()
+}
+
+fn read(file: &Value) -> Result<Drawing> {
+ Drawing::from_json(&file.to_string())
+}
+
+/// Why `file` is refused, or "read".
+fn refusal(file: &Value) -> String {
+ read(file).map_or_else(|e| e.to_string(), |_| "read".into())
+}
+
+/// Why `d`'s file, changed by `edit`, is refused, or "read".
+fn refused(d: &Drawing, edit: impl FnOnce(&mut Value)) -> String {
+ let mut v = file(d);
+ edit(&mut v);
+ refusal(&v)
+}
+
+/// A drawing reads back as it was saved, and save, open and save again writes the same bytes, as
+/// does another run from the same seed. The file holds each field under the record's name for it,
+/// ids as their 13 characters, and no counter.
+#[test]
+fn a_drawing_reads_back_as_saved_and_saves_the_same_bytes_again() {
+ let d = plate();
+ let saved = d.to_json().unwrap();
+ let reopened = Drawing::from_json(&saved).unwrap();
+ assert_eq!(reopened, d);
+ assert_eq!(reopened.to_json().unwrap(), saved);
+ assert_eq!(plate().to_json().unwrap(), saved, "a seeded run makes the same drawing");
+ let v = file(&d);
+ let [plate_id, bolt_id, bracket_id] = [0, 1, 2].map(|i| ids::encode(d.sources[i].id));
+ let [assembly_id, bolt_sheet_id] = [0, 1].map(|i| ids::encode(d.sheets[i].id));
+ assert_eq!(assembly_id, "1ge30wkvq38r0", "the seed's first id, as splitmix64 gives it");
+ assert_eq!(v["format"], DRAWING.format_string(DRAWING.current()));
+ assert_eq!(v.get("format_pending").is_some(), !DRAWING.pending_names().is_empty());
+ assert_eq!(v.get("next_id"), None);
+ assert_eq!((&v["name"], &v["language"]), (&json!("Plate assembly"), &json!("en-GB")));
+ assert_eq!(
+ v["sources"],
+ json!([{"id": plate_id, "path": "plate.sc"}, {"id": bolt_id, "path": "../parts/bolt.sc"}, {"id": bracket_id, "path": "bracket.sc"}])
+ );
+ assert_eq!(v["properties"], json!({"author": "Jane Doe"}));
+ assert_eq!(v["units"], json!({"fixed": {"unit": "in"}}));
+ assert_eq!((&v["sheets"][0]["id"], &v["sheets"][0]["dpi"]), (&json!(assembly_id), &json!(300.0)));
+ assert_eq!(v["sheets"][0]["sheet"], json!({"size": {"standard": "a3"}, "orientation": "landscape"}));
+ assert_eq!(v["sheets"][0]["documents"], json!({"source": plate_id, "component": 7}));
+ assert_eq!(v["sheets"][0]["excluded"], json!({"count": false, "print": false}));
+ assert_eq!(
+ v["sheets"][1],
+ json!({
+ "id": bolt_sheet_id, "name": "Bolt", "sheet": {"size": {"standard": "a4"}, "orientation": "portrait"},
+ "border": serde_json::to_value(own_border()).unwrap(), "dpi": 600.0,
+ "documents": {"source": bolt_id, "component": 0}, "excluded": {"count": false, "print": true}
+ })
+ );
+}
+
+/// A hand-written file may leave out what has a default, and reads as a new drawing has it; the
+/// rest is needed.
+#[test]
+fn a_file_may_leave_out_what_has_a_default() {
+ let minimal = json!({
+ "format": DRAWING.format_string(1),
+ "name": "Bracket",
+ "sources": [],
+ "language": "de",
+ "sheets": [{"id": "0000000000001", "name": "Blatt 1", "sheet": {"size": {"standard": "a3"}}}]
+ });
+ let d = read(&minimal).unwrap();
+ assert_eq!((d.sheets[0].id, &d.units, d.properties.is_empty()), (1, &Units::FollowModel, true));
+ let sheet = &d.sheets[0];
+ assert_eq!(sheet.sheet, drawing_sheet::Sheet::standard(PaperSize::A3, Orientation::Landscape));
+ assert_eq!((sheet.border, sheet.dpi, sheet.documents, sheet.excluded), (None, DEFAULT_DPI, None, Excluded::default()));
+ // The format as this build writes it, however the file spelt it.
+ let mut spelt = minimal.clone();
+ spelt["format"] = json!("solidcraft-drawing/+1");
+ assert_eq!(read(&spelt).unwrap().format, DRAWING.format_string(DRAWING.current()));
+ for key in ["name", "sources", "language", "sheets"] {
+ let mut v = minimal.clone();
+ v.as_object_mut().unwrap().remove(key);
+ let why = refusal(&v);
+ assert!(why.starts_with("damaged drawing: ") && why.contains(&format!("missing field `{key}`")), "{why}");
+ }
+}
+
+/// Every cap on both sides: sheets, sources, the bytes of paths and names (two-byte characters too).
+#[test]
+fn every_cap_holds_on_both_sides() {
+ let base = file(&bare());
+ let with = |key: &str, value: Value| {
+ let mut v = base.clone();
+ v[key] = value;
+ v
+ };
+ let sheet = base["sheets"][0].clone();
+ let sheets = |n: u64| {
+ let one = |id: u64| {
+ let mut s = sheet.clone();
+ s["id"] = json!(ids::encode(id));
+ s
+ };
+ Value::Array((1..=n).map(one).collect())
+ };
+ assert_eq!(read(&with("sheets", sheets(1000))).unwrap().sheets.len(), 1000);
+ for n in [0, 1001] {
+ assert_eq!(refusal(&with("sheets", sheets(n))), "damaged drawing: a drawing has 1 to 1000 sheets", "{n} sheets");
+ }
+ // Sources from id 1: the sheet's id is the seed's, far from them.
+ let sources = |n: u64| Value::Array((1..=n).map(|id| json!({"id": ids::encode(id), "path": format!("part{id}.sc")})).collect());
+ assert_eq!(read(&with("sources", sources(64))).unwrap().sources.len(), 64);
+ assert_eq!(refusal(&with("sources", sources(65))), "damaged drawing: a drawing draws at most 64 designs");
+ let path = |p: &str| refusal(&with("sources", json!([{"id": ids::encode(1), "path": p}])));
+ for fits in ["a".repeat(4096), "é".repeat(2048), "/".into()] {
+ assert_eq!(path(fits.as_str()), "read", "{} bytes", fits.len());
+ }
+ let rule = "damaged drawing: source 0000000000001: a design's path is 1 to 4096 bytes, without NUL";
+ for broken in ["a".repeat(4097), "é".repeat(2048) + "a", String::new(), "plate\0.sc".into()] {
+ assert_eq!(path(broken.as_str()), rule, "{} bytes", broken.len());
+ }
+ let names = |name: &str| {
+ let mut sheet_named = base.clone();
+ sheet_named["sheets"][0]["name"] = json!(name);
+ (refusal(&with("name", json!(name))), refusal(&sheet_named))
+ };
+ for fits in ["x".repeat(256), "é".repeat(128), "A".into(), "Blatt 1 – Übersicht".into()] {
+ assert_eq!(names(fits.as_str()), ("read".to_string(), "read".to_string()), "{} bytes", fits.len());
+ }
+ let rule = "name is 1 to 256 bytes, not only spaces, without control characters";
+ let sheet_id = ids::encode(bare().sheets[0].id);
+ for broken in ["x".repeat(257), "é".repeat(128) + "a", String::new(), " ".into(), "two\nlines".into(), "bell\u{7}".into(), "nul\0".into()] {
+ let expected = (format!("damaged drawing: the drawing's {rule}"), format!("damaged drawing: sheet {sheet_id}: its {rule}"));
+ assert_eq!(names(broken.as_str()), expected, "{broken:?}");
+ }
+}
+
+/// The content language is a well-formed BCP 47 tag of 2 to 35 characters.
+#[test]
+fn the_language_is_a_bcp_47_tag_of_2_to_35_characters() {
+ let base = file(&bare());
+ let why = |tag: &str| {
+ let mut v = base.clone();
+ v["language"] = json!(tag);
+ refusal(&v)
+ };
+ let longest = "en-abcdefgh-abcdefgh-abcdefgh-abcde";
+ assert_eq!(longest.len(), 35);
+ for tag in ["en", "de", "ast", "en-GB", "EN-gb", "zh-Hans-CN", "sr-Latn-RS", "es-419", longest] {
+ assert_eq!(why(tag), "read", "{tag}");
+ }
+ let rule = "damaged drawing: the language is not a BCP 47 tag of 2 to 35 characters (such as `en` or `en-GB`)";
+ let too_long = format!("{longest}f");
+ let broken =
+ ["e", "", too_long.as_str(), "en_GB", "en-", "-en", "en--GB", "e1", "x-private", "en-abcdefghi", "abcdefghi", "日本", "en GB", "en\n"];
+ for tag in broken {
+ assert_eq!(why(tag), rule, "{tag:?}");
+ }
+}
+
+/// A fixed unit is a length unit of the expression unit table, written as the table writes it.
+#[test]
+fn a_fixed_unit_is_a_length_unit_of_the_expression_table() {
+ let base = file(&bare());
+ let units = |units: Value| {
+ let mut v = base.clone();
+ v["units"] = units;
+ read(&v).map(|d| d.units)
+ };
+ for (unit, kind, _) in expr::UNITS {
+ assert_eq!(units(json!({"fixed": {"unit": unit}})).is_ok(), kind == expr::Kind::Length, "{unit}");
+ }
+ assert_eq!(units(json!({"fixed": {"unit": "in"}})).unwrap(), Units::Fixed { unit: "in".into() });
+ assert_eq!(units(json!("follow_model")).unwrap(), Units::FollowModel);
+ let rule = "damaged drawing: the drawing's unit is not a length unit (such as `mm` or `in`)";
+ for unit in ["furlong", "deg", "°", "none", "", " in", "in ", "IN"] {
+ assert_eq!(units(json!({"fixed": {"unit": unit}})).unwrap_err().to_string(), rule, "{unit:?}");
+ }
+ for broken in [json!("follow_design"), json!({"fixed": "in"}), json!({"fixed": {}}), json!(null)] {
+ assert!(units(broken.clone()).is_err(), "{broken}");
+ }
+}
+
+/// A sheet's border is saved as a copy of its profile, field by field, and read back as saved, so
+/// a later built-in never changes it; a profile's name in its place is refused.
+#[test]
+fn a_border_is_saved_as_a_copy_of_its_profile() {
+ let v = file(&plate());
+ assert_eq!(v["sheets"][0]["border"], serde_json::to_value(DrawingBorderProfile::iso()).unwrap());
+ assert_eq!(v["sheets"][1]["border"], serde_json::to_value(own_border()).unwrap());
+ assert_eq!(read(&v).unwrap().sheets[1].border, Some(own_border()));
+ let mut edited = v.clone();
+ edited["sheets"][0]["border"]["margins"]["left_mm"] = json!(15.0);
+ let iso = DrawingBorderProfile::iso();
+ let wider = DrawingBorderProfile { margins: Margins { left_mm: 15.0, ..iso.margins }, ..iso };
+ assert_eq!(read(&edited).unwrap().sheets[0].border, Some(wider));
+ edited["sheets"][0]["border"] = json!("iso");
+ assert!(refusal(&edited).starts_with("damaged drawing: "));
+ edited["sheets"][0]["border"] = Value::Null;
+ assert_eq!(read(&edited).unwrap().sheets[0].border, None, "no drawing border");
+}
+
+/// What reading refuses: each damage the rules name, refused rather than patched, and files this
+/// build can't read.
+#[test]
+fn damaged_files_are_refused_and_never_patched() {
+ let d = plate();
+ let plate_id = ids::encode(d.sources[0].id);
+ let [assembly_id, bolt_sheet_id] = [0, 1].map(|i| ids::encode(d.sheets[i].id));
+ // Two objects with one id, of one kind and of two kinds.
+ assert_eq!(refused(&d, |v| v["sources"][1]["id"] = json!(plate_id)), format!("damaged drawing: two objects have the id {plate_id}"));
+ assert_eq!(refused(&d, |v| v["sheets"][1]["id"] = json!(assembly_id)), format!("damaged drawing: two objects have the id {assembly_id}"));
+ assert_eq!(refused(&d, |v| v["sources"][2]["id"] = json!(bolt_sheet_id)), format!("damaged drawing: two objects have the id {bolt_sheet_id}"));
+ // An id that isn't one, where an object has it and where a reference names it; no number form,
+ // and no counter.
+ let not_an_id = "damaged drawing: an id is 13 characters of lowercase Crockford base32, not all 0";
+ for text in ["0000000000000", "FZZZZZZZZZZZZ", "000000000001", "0000000000001 ", "000000000000o", "g000000000000"] {
+ assert_eq!(refused(&d, |v| v["sources"][2]["id"] = json!(text)), not_an_id, "{text:?}");
+ assert_eq!(refused(&d, |v| v["sheets"][1]["documents"]["source"] = json!(text)), not_an_id, "{text:?}");
+ }
+ assert!(refused(&d, |v| v["sources"][2]["id"] = json!(5)).starts_with("damaged drawing: invalid type"));
+ assert!(refused(&d, |v| v["next_id"] = json!(6)).contains("unknown field `next_id`"));
+ let mut in_memory = d.clone();
+ in_memory.sources[2].id = 0;
+ assert_eq!(in_memory.validate().unwrap_err().to_string(), "an object has the id 0, which is never one");
+ // A reference to nothing, or to an object of another kind; a source a sheet documents removed.
+ for missing in [ids::encode(99), assembly_id.clone()] {
+ let expected = format!("damaged drawing: sheet {bolt_sheet_id}: it documents source {missing}, which the drawing doesn't have");
+ assert_eq!(refused(&d, |v| v["sheets"][1]["documents"]["source"] = json!(missing)), expected);
+ }
+ let without_plate = refused(&d, |v| {
+ v["sources"].as_array_mut().unwrap().remove(0);
+ });
+ assert_eq!(without_plate, format!("damaged drawing: sheet {assembly_id}: it documents source {plate_id}, which the drawing doesn't have"));
+ // The paper, its border and its resolution, through the sheet's own rules.
+ let custom = |sides: Value| refused(&d, |v| v["sheets"][0]["sheet"]["size"] = json!({"custom": {"sides_mm": sides}}));
+ assert_eq!(custom(json!([5000.0, 0.5])), "read");
+ for sides in [json!([5000.1, 100.0]), json!([0.0, 100.0]), json!([-1.0, 100.0])] {
+ let expected = format!("damaged drawing: sheet {assembly_id}: drawing sheet: a custom side is finite, above 0 and at most 5000 mm");
+ assert_eq!(custom(sides), expected);
+ }
+ let why = custom(json!([1e10, 100.0]));
+ assert!(why.starts_with("damaged drawing: the number ") && why.ends_with(" is out of range"), "checked before the record: {why}");
+ let nan = d.to_json().unwrap().replacen("600.0", "NaN", 1);
+ assert!(Drawing::from_json(&nan).unwrap_err().to_string().starts_with("not a SolidCraft drawing: "), "NaN isn't JSON");
+ assert_eq!(
+ refused(&d, |v| v["sheets"][1]["border"]["margins"]["top_mm"] = json!(-1.0)),
+ format!("damaged drawing: sheet {bolt_sheet_id}: drawing sheet: a margin is finite and 0 to 5000 mm")
+ );
+ for dpi in [25.0, 2400.0] {
+ assert_eq!(refused(&d, |v| v["sheets"][1]["dpi"] = json!(dpi)), "read", "{dpi}");
+ }
+ for dpi in [24.9, 2400.1, 0.0, -300.0] {
+ let expected = format!("damaged drawing: sheet {bolt_sheet_id}: its pictures are 25 to 2400 dpi");
+ assert_eq!(refused(&d, |v| v["sheets"][1]["dpi"] = json!(dpi)), expected, "{dpi}");
+ }
+ // In memory, where NaN can be, the same rules.
+ let mut in_memory = plate();
+ Arc::make_mut(&mut in_memory.sheets[1]).dpi = f64::NAN;
+ assert_eq!(in_memory.validate().unwrap_err().to_string(), format!("sheet {bolt_sheet_id}: its pictures are 25 to 2400 dpi"));
+ let sheet = Arc::make_mut(&mut in_memory.sheets[1]);
+ sheet.dpi = DEFAULT_DPI;
+ sheet.sheet.size = SheetSize::Custom { sides_mm: [f64::NAN, 100.0] };
+ assert!(in_memory.validate().unwrap_err().to_string().starts_with(&format!("sheet {bolt_sheet_id}: drawing sheet: a custom side")));
+ // An unknown field anywhere.
+ let unknown: [fn(&mut Value); 8] = [
+ |v| v["views"] = json!([]),
+ |v| v["sources"][0]["name"] = json!("Plate"),
+ |v| v["sheets"][0]["scale"] = json!(1),
+ |v| v["sheets"][0]["sheet"]["colour"] = json!("white"),
+ |v| v["sheets"][0]["border"]["style"] = json!("iso"),
+ |v| v["sheets"][0]["documents"]["view"] = json!(1),
+ |v| v["sheets"][0]["excluded"]["export"] = json!(true),
+ |v| v["units"]["fixed"]["precision"] = json!(2),
+ ];
+ for (i, edit) in unknown.into_iter().enumerate() {
+ let why = refused(&d, edit);
+ assert!(why.starts_with("damaged drawing: ") && why.contains("unknown field"), "{i}: {why}");
+ }
+ // A newer build's file is refused as one before anything in it is read: a field this build
+ // doesn't know, or a number out of its range.
+ let (current, newer) = (DRAWING.current(), DRAWING.current() + 1);
+ let why = refused(&d, |v| {
+ v["format"] = json!(DRAWING.format_string(newer));
+ v["views"] = json!([]);
+ v["sheets"][0]["dpi"] = json!(1e10);
+ });
+ assert_eq!(
+ why,
+ format!(
+ "this drawing was saved by a newer SolidCraft (file format {newer}; this version reads formats up to {current}): update SolidCraft to open it"
+ )
+ );
+ // A list of pending changes means nothing beside a format made of none; beside the pending
+ // number, a change this build doesn't know is a newer build's.
+ let why = refused(&d, |v| v["format_pending"] = json!(["a-later-change"]));
+ if DRAWING.pending_names().is_empty() {
+ assert_eq!(why, "read");
+ } else {
+ assert!(why.contains("newer SolidCraft"), "{why}");
+ }
+ // A design is never read as a drawing, nor a drawing as a design.
+ let design = crate::Document::new("Plate").to_json();
+ let design_format = crate::format::format_string(crate::format::FORMAT);
+ assert_eq!(Drawing::from_json(&design).unwrap_err().to_string(), format!("not a SolidCraft drawing (format `{design_format}`)"));
+ let drawing_format = DRAWING.format_string(current);
+ assert_eq!(
+ crate::Document::from_json(&d.to_json().unwrap()).unwrap_err().to_string(),
+ format!("not a SolidCraft design (format `{drawing_format}`)")
+ );
+ // Not an object, not JSON, nested too deeply, too large.
+ assert_eq!(Drawing::from_json("[]").unwrap_err().to_string(), "not a SolidCraft drawing (expected a JSON object)");
+ assert!(Drawing::from_json("").unwrap_err().to_string().starts_with("not a SolidCraft drawing: "));
+ let deep: Value = serde_json::from_str(&format!("{}1{}", "[".repeat(100), "]".repeat(100))).unwrap();
+ assert_eq!(refused(&d, |v| v["views"] = deep), "damaged drawing: nested too deeply");
+ let deeper = format!("{{\"format\": \"{drawing_format}\", \"views\": {}1{}}}", "[".repeat(200), "]".repeat(200));
+ assert!(Drawing::from_json(&deeper).unwrap_err().to_string().starts_with("not a SolidCraft drawing: "));
+ let text = d.to_json().unwrap();
+ let at_cap = text.clone() + &" ".repeat(MAX_DRAWING_BYTES - text.len());
+ assert_eq!(Drawing::from_json(&at_cap).unwrap(), d);
+ assert_eq!(Drawing::from_json(&(at_cap + " ")).unwrap_err().to_string(), "drawing too large (at most 16 MiB)");
+}
+
+/// A run never gives an id twice: not one in use, and not a removed object's. Only another run from
+/// the same seed, which tests and replays start from the same file, can give a removed id again.
+#[test]
+fn a_run_never_gives_an_id_twice() {
+ let mut id_source = IdSource::seeded(SEED);
+ let a4 = drawing_sheet::Sheet::standard(PaperSize::A4, Orientation::Landscape);
+ let mut d = Drawing::new("Ids", "en", "Sheet", a4, None, &mut id_source).unwrap();
+ let mut given = BTreeSet::from([d.sheets[0].id]);
+ for _ in 0..MAX_SOURCES {
+ let id = d.allocate_id(&mut id_source).unwrap();
+ d.sources.push(Source { id, path: "part.sc".into() });
+ assert!(given.insert(id), "{id:#x} given twice");
+ }
+ let removed = d.sources.pop().unwrap().id;
+ for _ in 0..10_000 {
+ let id = d.allocate_id(&mut id_source).unwrap();
+ assert!(id != removed && given.insert(id), "{id:#x} given twice");
+ }
+ // The same seed, from the start, over a file it made: every draw up to the removed id is in use.
+ let reopened = Drawing::from_json(&d.to_json().unwrap()).unwrap();
+ let again = reopened.allocate_id(&mut IdSource::seeded(SEED)).unwrap();
+ assert!(!reopened.ids().any(|id| id == again));
+ assert_eq!(again, removed);
+}
+
+/// Properties follow the design metadata's rules: other tools' data and a well-known key of another
+/// kind are kept as they are, never read as numbers, while the same number elsewhere is refused.
+#[test]
+fn properties_are_kept_as_they_are() {
+ let mut v = file(&plate());
+ v["properties"]["com.example.pdm"] = json!({"huge": 1e300, "ids": [1, 2, 3]});
+ v["properties"]["revision"] = json!(3);
+ let d = read(&v).unwrap();
+ assert_eq!(d.properties.get("com.example.pdm"), Some(&json!({"huge": 1e300, "ids": [1, 2, 3]})));
+ assert_eq!((d.properties.revision(), d.properties.get("revision")), (None, Some(&json!(3))));
+ assert_eq!(read(&file(&d)).unwrap(), d);
+ v["sheets"][0]["dpi"] = json!(1e300);
+ let why = refusal(&v);
+ assert!(why.starts_with("damaged drawing: the number ") && why.ends_with(" is out of range"), "{why}");
+}
+
+/// A drawing whose JSON would be over the read limit isn't saved. Other tools' properties are kept
+/// as they came, and indenting them can grow a file read in under the limit past it, so the save
+/// refuses rather than write a file that won't open: every drawing saved opens again.
+#[test]
+fn a_drawing_too_large_to_reopen_is_not_saved() {
+ let file = |zeros: usize| {
+ let items = vec!["0"; zeros].join(",");
+ let sheet = r#"{"id":"0000000000001","name":"S","sheet":{"size":{"standard":"a4"}}}"#;
+ let format = DRAWING.format_string(1);
+ format!(
+ r#"{{"format":"{format}","name":"A","sources":[],"language":"en","sheets":[{sheet}],"properties":{{"com.example":{{"items":[{items}]}}}}}}"#
+ )
+ };
+ // The case found in review (#3891): 2,000,000 zeros read in at about 4 MB and indent past 16 MiB.
+ let big = Drawing::from_json(&file(2_000_000)).unwrap();
+ assert_eq!(big.to_json().unwrap_err().to_string(), "drawing too large to save (at most 16 MiB)");
+ let small = Drawing::from_json(&file(100_000)).unwrap();
+ assert_eq!(Drawing::from_json(&small.to_json().unwrap()).unwrap(), small);
+}
+
+/// A new drawing has one sheet, its id the source's first, follows its designs' units and renders
+/// pictures at 300 dpi; a name, language or border that breaks the rules is refused.
+#[test]
+fn a_new_drawing_has_one_sheet_and_keeps_the_rules() {
+ let d = bare();
+ let first = IdSource::seeded(SEED).next(&BTreeSet::new()).unwrap();
+ assert_eq!((d.sheets.len(), d.sheets[0].id, d.sheets[0].dpi, &d.units), (1, first, DEFAULT_DPI, &Units::FollowModel));
+ assert_eq!((d.format, d.format_pending), (DRAWING.format_string(DRAWING.current()), DRAWING.pending_names()));
+ let a4 = drawing_sheet::Sheet::standard(PaperSize::A4, Orientation::Landscape);
+ let thin = DrawingBorderProfile { drawing_border_line_mm: 0.0, ..DrawingBorderProfile::iso() };
+ let broken = [("", "en", "Sheet", None), ("Bare", "en_GB", "Sheet", None), ("Bare", "en", "\n", None), ("Bare", "en", "Sheet", Some(thin))];
+ for (name, language, sheet, border) in broken {
+ let made = Drawing::new(name, language, sheet, a4, border, &mut IdSource::seeded(SEED));
+ assert!(made.is_err(), "{name:?} {language:?} {sheet:?} {border:?}");
+ }
+}
+
+/// Hostile input never panics: a valid file's text cut, overwritten and given lies, and its JSON
+/// values replaced, repeated and dropped. Each read gives an error, or a drawing that keeps the
+/// rules and reads back as it saves.
+#[test]
+fn mutated_files_give_an_error_or_a_valid_drawing_never_a_panic() {
+ let good = plate().to_json().unwrap();
+ let tree: Value = serde_json::from_str(&good).unwrap();
+ let nodes = count(&tree) as u64;
+ let lies = [
+ json!(null),
+ json!(0),
+ json!(-1),
+ json!(1),
+ json!(1e10),
+ json!(u64::MAX),
+ json!(""),
+ json!("x".repeat(300)),
+ json!("0000000000000"),
+ json!("0000000000001"),
+ json!("fzzzzzzzzzzzz"),
+ json!("FZZZZZZZZZZZZ"),
+ json!([]),
+ json!({}),
+ json!(true),
+ json!("follow_model"),
+ json!({"fixed": {"unit": "deg"}}),
+ ];
+ let words = ["NaN", "1e400", "-0", "18446744073709551616", "\"", "{", "]", ",", "null", "\u{0}", "é", "o", "I"];
+ let mut seed: u64 = 0x9e37_79b9_7f4a_7c15;
+ let mut rnd = move || {
+ seed ^= seed << 13;
+ seed ^= seed >> 7;
+ seed ^= seed << 17;
+ seed
+ };
+ let mut read_back = 0;
+ for i in 0..10_000 {
+ let text = if i % 2 == 0 {
+ let mut v = tree.clone();
+ let lie = &lies[(rnd() % lies.len() as u64) as usize];
+ mutate(&mut v, &mut ((rnd() % nodes) as usize), lie, rnd() % 3);
+ v.to_string()
+ } else {
+ let mut s = good.clone().into_bytes();
+ for _ in 0..1 + rnd() % 3 {
+ // A run of up to 15 bytes taken out, overwritten by one byte or replaced by a lie.
+ let at = (rnd() % (s.len() as u64 + 1)) as usize;
+ let cut = ((rnd() % 16) as usize).min(s.len() - at);
+ let byte = [(rnd() >> 56) as u8];
+ let put: &[u8] = match rnd() % 3 {
+ 0 => &[],
+ 1 => &byte,
+ _ => words[(rnd() % words.len() as u64) as usize].as_bytes(),
+ };
+ let next = [&s[..at], put, &s[at + cut..]].concat();
+ s = next;
+ if rnd() % 8 == 0 {
+ s.truncate(at);
+ }
+ }
+ String::from_utf8_lossy(&s).into_owned()
+ };
+ if let Ok(d) = Drawing::from_json(&text) {
+ assert!(d.validate().is_ok() && d.ids().all(|id| id != 0), "{text}");
+ assert_eq!(Drawing::from_json(&d.to_json().unwrap()).unwrap(), d, "{text}");
+ read_back += 1;
+ }
+ }
+ assert!(read_back > 50, "only {read_back} mutated files read: the mutations hardly reach the record's rules");
+}
+
+/// The number of values in `v`, itself included.
+fn count(v: &Value) -> usize {
+ 1 + match v {
+ Value::Array(a) => a.iter().map(count).sum::<usize>(),
+ Value::Object(o) => o.values().map(count).sum(),
+ _ => 0,
+ }
+}
+
+/// Change the `pick`th value of `v`, depth first: `how` 1 repeats a list's first element (two
+/// objects with one id), 2 drops an object's first field, and otherwise `lie` takes its place.
+fn mutate(v: &mut Value, pick: &mut usize, lie: &Value, how: u64) -> bool {
+ if *pick == 0 {
+ match (v, how) {
+ (Value::Array(a), 1) if !a.is_empty() => {
+ let first = a[0].clone();
+ a.push(first);
+ }
+ (Value::Object(o), 2) if !o.is_empty() => {
+ let key = o.keys().next().cloned().unwrap_or_default();
+ o.remove(&key);
+ }
+ (v, _) => *v = lie.clone(),
+ }
+ return true;
+ }
+ *pick -= 1;
+ match v {
+ Value::Array(a) => a.iter_mut().any(|x| mutate(x, pick, lie, how)),
+ Value::Object(o) => o.values_mut().any(|x| mutate(x, pick, lie, how)),
+ _ => false,
+ }
+}
diff --git a/crates/doc/src/eval_more.rs b/crates/doc/src/eval_more.rs
index f7fb17000d..2e94d4a6e3 100644
--- a/crates/doc/src/eval_more.rs
+++ b/crates/doc/src/eval_more.rs
@@ -485,7 +485,7 @@ fn mirror_y(r: &Region2) -> Region2 {
.iter()
.map(|s| match *s {
Seg2::Arc { center, radius, start, sweep } => Seg2::Arc { center: f(center), radius, start: -start, sweep: -sweep },
- other => sheet::map_controls(&other, f),
+ other => other.map_controls(f),
})
.collect();
Loop2 { segs }.ccw()
diff --git a/crates/doc/src/format.rs b/crates/doc/src/format.rs
index ff4005e1d4..72d2af11bc 100644
--- a/crates/doc/src/format.rs
+++ b/crates/doc/src/format.rs
@@ -232,6 +232,11 @@
//! this build writes the next number (which no release reads), with the names of these changes
//! in `format_pending`, so a later build applies just the steps a file is missing. At release
//! time `scripts/fold-format-pending.sh` moves them into the next `v<N>/`.
+//!
+//! Drawings (`solidcraft-drawing/N`, #3890) are versioned by the same code ([`Family`]) from their
+//! own first format, 1 (the record in [`crate::drawing`]): each later change is one file in
+//! `src/drawing/format/`, in `v<N>/` or `pending/` as above, and the release script folds that
+//! folder too.
use serde_json::Value;
@@ -244,11 +249,11 @@ pub const FORMAT: u32 = FORMATS.current();
/// of [`Part`]s (`src/format/`, listed by `build.rs`).
const HAND_WRITTEN: u32 = 22;
-/// One change to the file format: a file in `src/format/v<N>/` or `src/format/pending/`.
+/// One change to a family's file format: a file in its `v<N>/` or `pending/` folder.
pub(crate) struct Part {
/// The file's name, which a file written while the change was pending lists.
pub name: &'static str,
- /// How a design from before the change is rewritten as it opens, if it is.
+ /// How a file from before the change is rewritten as it opens, if it is.
pub step: Option<JsonStep>,
}
@@ -257,13 +262,102 @@ include!(concat!(env!("OUT_DIR"), "/format_parts.rs"));
/// Every format this build knows and how to upgrade a design through them.
const FORMATS: Formats<'static> = Formats { hand: &JSON_STEPS, folded: FOLDED, pending: PENDING };
+/// A kind of file whose format is versioned here: designs, and drawings (#3890). Each family has
+/// its own format tag, its own numbers and its own folder of change files (`build.rs` lists them);
+/// reading a file's format, refusing a file a newer build saved and the upgrade are the same code
+/// for every family.
+pub struct Family<'a> {
+ /// What a file of the family is called in messages.
+ noun: &'static str,
+ /// The tag before the number in a file's `format`.
+ prefix: &'static str,
+ /// The tag files saved before the rename carry: read, never written (docs/compatibility.md).
+ legacy_prefix: Option<&'static str>,
+ /// The format of a file that names none: designs saved before format strings are format 1; a
+ /// drawing always names its own.
+ untagged: Option<u32>,
+ formats: Formats<'a>,
+}
+
+/// Designs (`solidcraft/N`): the upgrade steps written out up to format 22, then the change files
+/// in `src/format/`.
+pub const DESIGN: Family<'static> =
+ Family { noun: "design", prefix: "solidcraft/", legacy_prefix: Some(LEGACY_FORMAT_PREFIX), untagged: Some(1), formats: FORMATS };
+
+/// Drawings (`solidcraft-drawing/N`, #3890): format 1 is the first drawing record, and every later
+/// change is a file in `src/drawing/format/`.
+pub const DRAWING: Family<'static> = Family {
+ noun: "drawing",
+ prefix: "solidcraft-drawing/",
+ legacy_prefix: None,
+ untagged: None,
+ formats: Formats { hand: &[], folded: DRAWING_FOLDED, pending: DRAWING_PENDING },
+};
+
+impl Family<'_> {
+ /// The format this build writes: the last folded one, or the next while changes are pending.
+ pub const fn current(&self) -> u32 {
+ self.formats.current()
+ }
+
+ /// The names of the pending changes this build writes into a file (`format_pending`).
+ pub fn pending_names(&self) -> Vec<String> {
+ self.formats.pending.iter().map(|p| p.name.to_string()).collect()
+ }
+
+ /// The format tag of format `n`.
+ pub fn format_string(&self, n: u32) -> String {
+ format!("{}{n}", self.prefix)
+ }
+
+ /// The version in one of this family's format tags; `None` for any other tag, another
+ /// family's included.
+ pub fn version_of(&self, s: &str) -> Option<u32> {
+ s.strip_prefix(self.prefix).or_else(|| self.legacy_prefix.and_then(|p| s.strip_prefix(p)))?.parse().ok()
+ }
+
+ /// Read a file's format and take its `format_pending` out of its JSON, before anything else
+ /// in it is read: a file that isn't this family's, or that a newer build saved, is refused
+ /// here, so nothing a newer build saved is judged by this build's rules.
+ pub fn take_version(&self, v: &mut Value) -> Result<(u32, Option<Vec<String>>)> {
+ let noun = self.noun;
+ let not_ours = |what: String| DocError::Invalid(format!("not a SolidCraft {noun} ({what})"));
+ let Some(obj) = v.as_object() else { return Err(not_ours("expected a JSON object".into())) };
+ let version = match obj.get("format") {
+ None => self.untagged.ok_or_else(|| not_ours("no format".into()))?,
+ Some(Value::String(f)) => self.version_of(f).ok_or_else(|| not_ours(format!("format `{f}`")))?,
+ Some(_) => return Err(not_ours("format is not a string".into())),
+ };
+ let applied = take_names(v, "format_pending", noun)?;
+ self.formats.check(noun, version, applied.as_deref())?;
+ Ok((version, applied))
+ }
+
+ /// Bring a file of format `version` up to this build's; `applied` is its `format_pending`
+ /// (both from [`Family::take_version`]).
+ pub fn upgrade(&self, v: &mut Value, version: u32, applied: Option<&[String]>) -> Result<()> {
+ self.formats.upgrade(self.noun, v, version, applied)
+ }
+
+ /// Every number a file of the family holds is in range ([`check_numbers`]), but for its
+ /// top-level `kept` field: other tools' data (a design's `metadata`, a drawing's `properties`),
+ /// kept as it is and never read as a number (#1015); parsing already bounds its nesting.
+ pub(crate) fn check_numbers(&self, v: &Value, kept: &str) -> Result<()> {
+ match v {
+ Value::Object(m) => m.iter().filter(|(k, _)| k.as_str() != kept).try_for_each(|(_, x)| check_numbers(x, self.noun, 1)),
+ v => check_numbers(v, self.noun, 0),
+ }
+ }
+}
+
/// The names of the pending changes this build writes into a design (`format_pending`).
pub fn pending_names() -> Vec<String> {
- FORMATS.pending.iter().map(|p| p.name.to_string()).collect()
+ DESIGN.pending_names()
}
-/// The upgrade path: the hand-written steps up to [`HAND_WRITTEN`], the folded formats after it
-/// (each a list of changes) and the pending changes, which make the next format.
+/// A family's upgrade path: the steps written out by hand (designs' up to [`HAND_WRITTEN`]), the
+/// folded formats after them (each a list of changes) and the pending changes, which make the
+/// next format.
struct Formats<'a> {
hand: &'a [JsonStep],
folded: &'a [(u32, &'a [Part])],
@@ -300,26 +394,41 @@ impl Formats<'_> {
}
}
- /// Bring a design of format `version` up to [`Formats::current`]. `applied` is the file's
+ /// Refuse a `noun` of format `version` that this build can't read: format 0, a newer number,
+ /// or a change `applied` (its `format_pending`) names that this build doesn't have anywhere in
+ /// its history, which only a newer build's file can. Changes are recognized across the entire
+ /// history: a branch's pending change may have landed at a later number. A list beside a format
+ /// that isn't made of changes means nothing (a tool or a test set an older number on a newer
+ /// file).
+ fn check(&self, noun: &str, version: u32, applied: Option<&[String]>) -> Result<()> {
+ let newer = |what: String| DocError::Invalid(format!("this {noun} was saved by a newer SolidCraft ({what}): update SolidCraft to open it"));
+ let current = self.current();
+ if version == 0 {
+ return Err(DocError::Invalid(format!("not a SolidCraft {noun} (format 0)")));
+ }
+ if version > current {
+ return Err(newer(format!("file format {version}; this version reads formats up to {current}")));
+ }
+ let applied = applied.filter(|_| self.parts(version).is_some()).unwrap_or_default();
+ match applied.iter().find(|name| !self.knows_part_name(self.canonical_applied_name(version, name))) {
+ Some(unknown) => Err(newer(format!("file format {version} with `{unknown}`, which this version doesn't know"))),
+ None => Ok(()),
+ }
+ }
+
+ /// Bring a `noun` of format `version` up to [`Formats::current`]. `applied` is the file's
/// `format_pending`: the changes of its format it already has, when it was written while they
- /// were pending; the others' steps run first. Recognize changes across the entire history:
- /// a branch's pending change may have landed at a later number. Unknown changes are refused
- /// even after folding, and already-applied changes never run again at their later number.
- fn upgrade(&self, v: &mut Value, version: u32, applied: Option<&[String]>) -> Result<()> {
- if version == 0 || version > self.current() {
- return Err(DocError::Invalid(format!("not a SolidCraft design (format {version})")));
- }
- // A list beside a format that isn't made of changes means nothing (a tool or a test set
- // an older number on a newer file): it is ignored, like any field an upgrade drops.
+ /// were pending; the others' steps run first. A file [`Formats::check`] refuses is refused,
+ /// whoever calls, before anything is changed; already-applied changes never run again at
+ /// their later number.
+ fn upgrade(&self, noun: &str, v: &mut Value, version: u32, applied: Option<&[String]>) -> Result<()> {
+ self.check(noun, version, applied)?;
+ // A list beside a format that isn't made of changes is ignored, like any field an upgrade
+ // drops.
let applied = applied.filter(|_| self.parts(version).is_some());
let already_applied =
|part: &Part| applied.is_some_and(|names| names.iter().any(|name| self.canonical_applied_name(version, name) == part.name));
- if let Some(applied) = applied {
- if let Some(unknown) = applied.iter().find(|name| !self.knows_part_name(self.canonical_applied_name(version, name))) {
- return Err(DocError::Invalid(format!(
- "this design was saved by a newer SolidCraft (file format {version} with `{unknown}`, which this version doesn't know): update SolidCraft to open it"
- )));
- }
+ if applied.is_some() {
for part in self.parts(version).unwrap_or_default().iter().filter(|part| !already_applied(part)) {
part.step.map_or(Ok(()), |step| step(v))?;
}
@@ -338,25 +447,26 @@ impl Formats<'_> {
}
}
-/// Take a file's `format_pending` (the pending changes it has) out of its JSON.
-fn take_pending(v: &mut Value) -> Result<Option<Vec<String>>> {
- let Some(list) = v.as_object_mut().and_then(|o| o.remove("format_pending")) else { return Ok(None) };
- let invalid = || DocError::Invalid("damaged design: `format_pending` is not a short list of names".into());
+/// Take a short list of names out of a file's JSON: its `format_pending` (the pending changes it
+/// has).
+fn take_names(v: &mut Value, key: &str, noun: &str) -> Result<Option<Vec<String>>> {
+ let Some(list) = v.as_object_mut().and_then(|o| o.remove(key)) else { return Ok(None) };
+ let invalid = || DocError::Invalid(format!("damaged {noun}: `{key}` is not a short list of names"));
let list = list.as_array().filter(|l| l.len() <= 1000).ok_or_else(invalid)?;
list.iter().map(|n| n.as_str().filter(|n| n.len() <= 128).map(str::to_string).ok_or_else(invalid)).collect::<Result<_>>().map(Some)
}
pub fn format_string(n: u32) -> String {
- format!("solidcraft/{n}")
+ DESIGN.format_string(n)
}
/// The format tag of designs saved before the rename. Compatibility shim (docs/compatibility.md):
/// read, never written.
pub const LEGACY_FORMAT_PREFIX: &str = "solvecraft/";
-/// The version in a format string (`solidcraft/N`, or the legacy `solvecraft/N`).
+/// The version in a design's format string (`solidcraft/N`, or the legacy `solvecraft/N`).
pub fn version_of(s: &str) -> Option<u32> {
- s.strip_prefix("solidcraft/").or_else(|| s.strip_prefix(LEGACY_FORMAT_PREFIX))?.parse().ok()
+ DESIGN.version_of(s)
}
/// JSON-level upgrades up to [`HAND_WRITTEN`]: entry `i` turns format `i + 1` into `i + 2`.
@@ -566,23 +676,7 @@ fn v2_to_v3(v: &mut Value) -> Result<()> {
/// Read a design file's JSON, upgrading older formats.
pub fn read(s: &str) -> Result<Document> {
let mut v: Value = serde_json::from_str(s).map_err(|e| DocError::Invalid(format!("not a SolidCraft design: {e}")))?;
- let Some(obj) = v.as_object() else {
- return Err(DocError::Invalid("not a SolidCraft design (expected a JSON object)".into()));
- };
- let version = match obj.get("format") {
- None => 1,
- Some(Value::String(f)) => version_of(f).ok_or_else(|| DocError::Invalid(format!("not a SolidCraft design (format `{f}`)")))?,
- Some(_) => return Err(DocError::Invalid("not a SolidCraft design (format is not a string)".into())),
- };
- let applied = take_pending(&mut v)?;
- if version == 0 {
- return Err(DocError::Invalid("not a SolidCraft design (format 0)".into()));
- }
- if version > FORMAT {
- return Err(DocError::Invalid(format!(
- "this design was saved by a newer SolidCraft (file format {version}; this version reads formats up to {FORMAT}): update SolidCraft to open it"
- )));
- }
+ let (version, applied) = DESIGN.take_version(&mut v)?;
check_design_numbers(&v)?;
crate::config::validate_rules_json(&v)?;
crate::config::validate_styles_json(&v)?;
@@ -594,7 +688,7 @@ pub fn read(s: &str) -> Result<Document> {
crate::format_offsets::validate_raw(&v)?;
let legacy_wires = validate_wires(&v, version)?;
validate_body_transfers(&v)?;
- FORMATS.upgrade(&mut v, version, applied.as_deref())?;
+ DESIGN.upgrade(&mut v, version, applied.as_deref())?;
let mut d: Document = serde_json::from_value(v).map_err(|e| DocError::Invalid(format!("design file: {e}")))?;
check_typed_numbers(&d)?;
let mut legacy_by_feature = std::collections::BTreeMap::<usize, Vec<usize>>::new();
@@ -1060,22 +1154,22 @@ const MAX_REAL: f64 = 1e9;
/// already bounds its nesting. Engineering SI constants have their own bounded admission
/// (e.g. E in Pa): only the exact root user-material card field bypasses the coordinate bound.
fn check_design_numbers(v: &Value) -> Result<()> {
- let Some(root) = v.as_object() else { return check_numbers(v, 0) };
+ let Some(root) = v.as_object() else { return check_numbers(v, "design", 0) };
for (key, value) in root {
if key == "metadata" {
continue;
}
if key != "user_materials" {
- check_numbers(value, 1)?;
+ check_numbers(value, "design", 1)?;
continue;
}
- let Some(materials) = value.as_array() else { return check_numbers(value, 1) };
+ let Some(materials) = value.as_array() else { return check_numbers(value, "design", 1) };
if materials.len() > crate::MAX_USER_MATERIALS {
return Err(DocError::Invalid("document exceeds 1000 user materials".into()));
}
for material in materials {
let Some(fields) = material.as_object() else {
- check_numbers(material, 2)?;
+ check_numbers(material, "design", 2)?;
continue;
};
for (field, data) in fields {
@@ -1084,7 +1178,7 @@ fn check_design_numbers(v: &Value) -> Result<()> {
if field == "physical_card" && !data.is_null() {
crate::physical_material::validate_card(data)?;
} else {
- check_numbers(data, 3)?;
+ check_numbers(data, "design", 3)?;
}
}
}
@@ -1102,21 +1196,22 @@ fn check_typed_numbers(d: &Document) -> Result<()> {
check_design_numbers(&typed)
}
-/// Every non-integer number outside separately validated engineering cards is finite and within ±`MAX_REAL` (a damaged or hostile
-/// file is refused instead of overflowing the geometry later).
-fn check_numbers(v: &Value, depth: usize) -> Result<()> {
+/// Every non-integer number in a `noun`'s file, outside separately validated engineering cards,
+/// is finite and within ±`MAX_REAL` (a damaged or hostile file is refused instead of overflowing
+/// the geometry later).
+fn check_numbers(v: &Value, noun: &str, depth: usize) -> Result<()> {
if depth > 64 {
- return Err(DocError::Invalid("damaged design: nested too deeply".into()));
+ return Err(DocError::Invalid(format!("damaged {noun}: nested too deeply")));
}
match v {
Value::Number(n) if !(n.is_u64() || n.is_i64()) => {
let x = n.as_f64().unwrap_or(f64::NAN);
if !(x.is_finite() && x.abs() <= MAX_REAL) {
- return Err(DocError::Invalid(format!("damaged design: the number {n} is out of range")));
+ return Err(DocError::Invalid(format!("damaged {noun}: the number {n} is out of range")));
}
}
- Value::Array(a) => a.iter().try_for_each(|x| check_numbers(x, depth + 1))?,
- Value::Object(m) => m.values().try_for_each(|x| check_numbers(x, depth + 1))?,
+ Value::Array(a) => a.iter().try_for_each(|x| check_numbers(x, noun, depth + 1))?,
+ Value::Object(m) => m.values().try_for_each(|x| check_numbers(x, noun, depth + 1))?,
_ => {}
}
Ok(())
@@ -1224,25 +1319,25 @@ mod tests {
assert_eq!(formats.current(), next);
for version in [1, HAND_WRITTEN, next - 1] {
let mut v = serde_json::json!({"features": [], "assembly": {"joints": [{"flip": false}]}});
- formats.upgrade(&mut v, version, None).unwrap();
+ formats.upgrade("design", &mut v, version, None).unwrap();
assert_eq!(trace_of(&v), ["a", "b"], "from format {version}");
// The hand-written steps ran too: format 3's joints were flipped on the way up.
assert_eq!(v["assembly"]["joints"][0]["flip"], Value::Bool(version < 4), "from format {version}");
}
// A design of the pending number written before `b-second` existed gets just that step.
let mut v = serde_json::json!({});
- formats.upgrade(&mut v, next, Some(&["a-first".to_string()])).unwrap();
+ formats.upgrade("design", &mut v, next, Some(&["a-first".to_string()])).unwrap();
assert_eq!(trace_of(&v), ["b"]);
// One that has both, or that this build wrote, needs nothing.
let mut v = serde_json::json!({});
- formats.upgrade(&mut v, next, Some(&["a-first".into(), "b-second".into()])).unwrap();
+ formats.upgrade("design", &mut v, next, Some(&["a-first".into(), "b-second".into()])).unwrap();
assert_eq!(trace_of(&v), Vec::<&str>::new());
// A change this build doesn't know is a newer build's: refused, not guessed at.
- let err = formats.upgrade(&mut serde_json::json!({}), next, Some(&["c-later".into()])).unwrap_err();
+ let err = formats.upgrade("design", &mut serde_json::json!({}), next, Some(&["c-later".into()])).unwrap_err();
assert!(err.to_string().contains("newer SolidCraft"), "{err}");
// A list on a format that isn't made of changes means nothing.
let mut v = serde_json::json!({});
- formats.upgrade(&mut v, HAND_WRITTEN, Some(&["a-first".into()])).unwrap();
+ formats.upgrade("design", &mut v, HAND_WRITTEN, Some(&["a-first".into()])).unwrap();
assert_eq!(trace_of(&v), ["a", "b"]);
}
@@ -1257,13 +1352,13 @@ mod tests {
let formats = Formats { hand: &JSON_STEPS, folded: &folded, pending: &[] };
assert_eq!(formats.current(), next);
let mut old = serde_json::json!({});
- formats.upgrade(&mut old, HAND_WRITTEN, None).unwrap();
+ formats.upgrade("design", &mut old, HAND_WRITTEN, None).unwrap();
assert_eq!(trace_of(&old), ["a", "b"]);
let mut nightly = serde_json::json!({});
- formats.upgrade(&mut nightly, next, Some(&["a-first".into()])).unwrap();
+ formats.upgrade("design", &mut nightly, next, Some(&["a-first".into()])).unwrap();
assert_eq!(trace_of(&nightly), ["b"]);
let mut released = serde_json::json!({});
- formats.upgrade(&mut released, next, None).unwrap();
+ formats.upgrade("design", &mut released, next, None).unwrap();
assert_eq!(trace_of(&released), Vec::<&str>::new());
}
@@ -1276,7 +1371,7 @@ mod tests {
let folded = Formats { hand: &hand, folded: &[(29, &first), (30, &cards)], pending: &[] };
for formats in [pending, folded] {
let mut file = serde_json::json!({"trace": ["b"]});
- formats.upgrade(&mut file, 29, Some(&["physical-material-cards".into()])).unwrap();
+ formats.upgrade("design", &mut file, 29, Some(&["physical-material-cards".into()])).unwrap();
assert_eq!(trace_of(&file), ["b", "a"], "never replay existing card semantics");
}
}
@@ -1288,7 +1383,7 @@ mod tests {
let formats = Formats { hand: &hand, folded: &[(29, &first)], pending: &[] };
let mut file = serde_json::json!({"trace": [], "sentinel": 7});
let original = file.clone();
- let error = formats.upgrade(&mut file, 29, Some(&["physical-material-cards".into()])).unwrap_err();
+ let error = formats.upgrade("design", &mut file, 29, Some(&["physical-material-cards".into()])).unwrap_err();
assert!(error.to_string().contains("physical-material-cards"), "{error}");
assert_eq!(file, original);
}
@@ -1303,7 +1398,7 @@ mod tests {
for version in [28, 30] {
let mut file = serde_json::json!({"trace": []});
let original = file.clone();
- let error = formats.upgrade(&mut file, version, Some(&["physical-material-cards".into()])).unwrap_err();
+ let error = formats.upgrade("design", &mut file, version, Some(&["physical-material-cards".into()])).unwrap_err();
assert!(error.to_string().contains("physical-material-cards"), "{error}");
assert_eq!(file, original);
}
@@ -1320,7 +1415,7 @@ mod tests {
{
let mut file = serde_json::json!({"trace": ["b"]});
let original = file.clone();
- let error = formats.upgrade(&mut file, 29, Some(&names)).unwrap_err();
+ let error = formats.upgrade("design", &mut file, 29, Some(&names)).unwrap_err();
assert!(error.to_string().contains("unknown-card-codec"), "{error}");
assert_eq!(file, original);
}
@@ -1337,7 +1432,7 @@ mod tests {
vec!["material-engineering-cards".into(), "physical-material-cards".into()],
] {
let mut file = serde_json::json!({"trace": ["b"]});
- formats.upgrade(&mut file, 29, Some(&names)).unwrap();
+ formats.upgrade("design", &mut file, 29, Some(&names)).unwrap();
assert_eq!(trace_of(&file), ["b", "a"]);
}
}
@@ -1350,7 +1445,7 @@ mod tests {
let formats = Formats { hand: &hand, folded: &[(29, &first)], pending: &cards };
let mut file = serde_json::json!({"trace": ["a"], "metadata": {"format_pending": ["physical-material-cards"]}});
let metadata = file["metadata"].clone();
- formats.upgrade(&mut file, 29, None).unwrap();
+ formats.upgrade("design", &mut file, 29, None).unwrap();
assert_eq!(trace_of(&file), ["a", "b"]);
assert_eq!(file["metadata"], metadata);
}
@@ -1365,7 +1460,7 @@ mod tests {
let formats = Formats { hand: &[], folded: &[(2, &parts)], pending };
let mut file = serde_json::json!({"trace": []});
let original = file.clone();
- let err = formats.upgrade(&mut file, 2, Some(&["experimental-card".into()])).unwrap_err();
+ let err = formats.upgrade("design", &mut file, 2, Some(&["experimental-card".into()])).unwrap_err();
assert!(err.to_string().contains("experimental-card") && err.to_string().contains("update SolidCraft"), "{err}");
assert_eq!(file, original, "refuse before applying even a known migration");
}
@@ -1381,14 +1476,192 @@ mod tests {
let folded = Formats { hand: &[], folded: &[(2, &first), (3, &later)], pending: &[] };
for formats in [pending, folded] {
let mut experimental = serde_json::json!({"trace": ["b"]});
- formats.upgrade(&mut experimental, 2, Some(&["b-second".into()])).unwrap();
+ formats.upgrade("design", &mut experimental, 2, Some(&["b-second".into()])).unwrap();
assert_eq!(trace_of(&experimental), ["b", "a"]);
let mut released = serde_json::json!({"trace": ["a"]});
- formats.upgrade(&mut released, 2, None).unwrap();
+ formats.upgrade("design", &mut released, 2, None).unwrap();
assert_eq!(trace_of(&released), ["a", "b"], "ordinary released files still get later migrations");
}
}
+ /// A design naming a pending change this build doesn't have is a newer build's, refused as
+ /// such before anything else in it is checked (as a newer number is), so a newer build's
+ /// fields never read as damage.
+ #[test]
+ fn a_newer_builds_pending_change_is_refused_before_the_design_is_checked() {
+ let mut file: Value = serde_json::from_str(&Document::new("A").to_json()).unwrap();
+ file["format_pending"] = serde_json::json!(["not-a-change-anyone-made"]);
+ file["features"] = serde_json::json!([{"type": "emboss", "face": {"body": "Body", "at": [0, 0, 0], "a_newer_key": true}}]);
+ let error = read(&file.to_string()).unwrap_err().to_string();
+ if PENDING.is_empty() {
+ assert!(error.contains("emboss face"), "a list beside a folded format means nothing: {error}");
+ } else {
+ assert_eq!(
+ error,
+ format!(
+ "this design was saved by a newer SolidCraft (file format {FORMAT} with `not-a-change-anyone-made`, which this version doesn't know): update SolidCraft to open it"
+ )
+ );
+ }
+ }
+
+ /// Drawings follow the same rules from their own first format: folded formats follow on from 1
+ /// (`v2/`, `v3/`, …), the next number is written while changes are pending, and the build lists
+ /// every change file in the drawing's folder, in file-name order.
+ #[test]
+ fn drawing_formats_follow_on_from_one_and_every_change_file_is_listed() {
+ for (i, (version, parts)) in DRAWING_FOLDED.iter().enumerate() {
+ assert_eq!(*version, 2 + i as u32);
+ assert!(!parts.is_empty(), "drawing format {version} has no changes");
+ }
+ assert_eq!(DRAWING.current(), 1 + DRAWING_FOLDED.len() as u32 + u32::from(!DRAWING_PENDING.is_empty()));
+ let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("src/drawing/format");
+ let names = |dir: &str| -> Vec<String> {
+ let mut names: Vec<String> = std::fs::read_dir(root.join(dir))
+ .map(|d| d.filter_map(|e| e.ok()?.file_name().to_str()?.strip_suffix(".rs").map(str::to_string)).collect())
+ .unwrap_or_default();
+ names.sort();
+ names
+ };
+ assert_eq!(names("pending"), DRAWING.pending_names());
+ for (version, parts) in DRAWING_FOLDED {
+ assert_eq!(names(&format!("v{version}")), parts.iter().map(|p| p.name).collect::<Vec<_>>());
+ }
+ }
+
+ /// A design's format tag never reads as a drawing's, nor a drawing's as a design's, at any
+ /// number: no family's tag starts another's, the legacy tag is a design's only, and each family
+ /// refuses the other's files by name.
+ #[test]
+ fn a_design_never_reads_as_a_drawing_or_the_other_way_round() {
+ let families = [&DESIGN, &DRAWING];
+ for a in families {
+ assert!(a.prefix.len() > 1 && a.prefix.ends_with('/'), "{}", a.prefix);
+ for b in families.into_iter().filter(|b| b.prefix != a.prefix) {
+ assert!(!a.prefix.starts_with(b.prefix), "{} starts {}", b.prefix, a.prefix);
+ }
+ }
+ for n in [0, 1, FORMAT, FORMAT + 1, DRAWING.current(), DRAWING.current() + 1, u32::MAX] {
+ assert_eq!(DESIGN.version_of(&DESIGN.format_string(n)), Some(n));
+ assert_eq!(DRAWING.version_of(&DRAWING.format_string(n)), Some(n));
+ assert_eq!(DRAWING.version_of(&DESIGN.format_string(n)), None, "{n}");
+ assert_eq!(DESIGN.version_of(&DRAWING.format_string(n)), None, "{n}");
+ assert_eq!(DRAWING.version_of(&format!("{LEGACY_FORMAT_PREFIX}{n}")), None, "{n}: the legacy tag is a design's");
+ }
+ for tag in [
+ "",
+ "solidcraft-drawing/",
+ "solidcraft-drawing",
+ "solidcraft-drawing/x",
+ "solidcraft-drawing/-1",
+ "solidcraft-drawing/4294967296",
+ "Solidcraft-drawing/1",
+ "solidcraft-drawing/1 ",
+ "solidcraft-drawings/1",
+ "solidcraft/drawing/1",
+ ] {
+ assert_eq!(DRAWING.version_of(tag), None, "{tag:?}");
+ }
+ // The number reads as Rust reads a `u32`, a leading `+` included, as in a design's tag.
+ assert_eq!(DRAWING.version_of("solidcraft-drawing/+1"), Some(1));
+ let error = DRAWING.take_version(&mut serde_json::json!({"format": format_string(FORMAT)})).unwrap_err().to_string();
+ assert_eq!(error, format!("not a SolidCraft drawing (format `solidcraft/{FORMAT}`)"));
+ let error = read(&serde_json::json!({"format": DRAWING.format_string(1)}).to_string()).unwrap_err().to_string();
+ assert_eq!(error, "not a SolidCraft design (format `solidcraft-drawing/1`)");
+ }
+
+ /// Every refusal names its family: a design's read exactly as they did before drawings had one
+ /// (the troubleshooting guide quotes them), a drawing's say "drawing". A file that names no
+ /// format is a design from before format strings, never a drawing.
+ #[test]
+ fn refusals_name_the_family_and_a_designs_read_as_before() {
+ use serde_json::json;
+ fn refusal(family: &Family<'_>, mut file: Value) -> String {
+ family.take_version(&mut file).map_or_else(|e| e.to_string(), |opened| format!("read as {opened:?}"))
+ }
+ fn tagged(family: &Family<'_>, n: u32) -> Value {
+ serde_json::json!({"format": family.format_string(n)})
+ }
+ fn newer(noun: &str, n: u32, current: u32) -> String {
+ format!(
+ "this {noun} was saved by a newer SolidCraft (file format {n}; this version reads formats up to {current}): update SolidCraft to open it"
+ )
+ }
+ assert_eq!(refusal(&DESIGN, tagged(&DESIGN, FORMAT + 1)), newer("design", FORMAT + 1, FORMAT));
+ assert_eq!(read(&tagged(&DESIGN, FORMAT + 1).to_string()).unwrap_err().to_string(), newer("design", FORMAT + 1, FORMAT));
+ let current = DRAWING.current();
+ assert!(matches!(DRAWING.take_version(&mut tagged(&DRAWING, current)), Ok((v, None)) if v == current));
+ for n in [current + 1, u32::MAX] {
+ assert_eq!(refusal(&DRAWING, tagged(&DRAWING, n)), newer("drawing", n, current));
+ }
+ for (family, noun) in [(&DESIGN, "design"), (&DRAWING, "drawing")] {
+ assert_eq!(refusal(family, tagged(family, 0)), format!("not a SolidCraft {noun} (format 0)"));
+ assert_eq!(refusal(family, json!([])), format!("not a SolidCraft {noun} (expected a JSON object)"));
+ assert_eq!(refusal(family, json!({"format": 1})), format!("not a SolidCraft {noun} (format is not a string)"));
+ assert_eq!(refusal(family, json!({"format": ""})), format!("not a SolidCraft {noun} (format ``)"));
+ // `format_pending`'s caps, on both sides of each.
+ let mut file = tagged(family, 1);
+ file["format_pending"] = vec!["x".repeat(128); 1000].into();
+ assert!(family.take_version(&mut file).is_ok(), "{noun}: 1,000 names of 128 bytes");
+ for damaged in [vec!["x".repeat(128); 1001], vec!["x".repeat(129)]] {
+ let mut file = tagged(family, 1);
+ file["format_pending"] = damaged.into();
+ assert_eq!(refusal(family, file), format!("damaged {noun}: `format_pending` is not a short list of names"));
+ }
+ }
+ // A change this build doesn't know, in a design of the pending number.
+ let pending = [traced("a-first")];
+ let design = Family { formats: Formats { hand: &JSON_STEPS, folded: FOLDED, pending: &pending }, ..DESIGN };
+ let next = design.current();
+ let file = json!({"format": format_string(next), "format_pending": ["c-later"]});
+ assert_eq!(
+ refusal(&design, file),
+ format!(
+ "this design was saved by a newer SolidCraft (file format {next} with `c-later`, which this version doesn't know): update SolidCraft to open it"
+ )
+ );
+ assert!(matches!(DESIGN.take_version(&mut json!({})), Ok((1, None))));
+ assert_eq!(refusal(&DRAWING, json!({})), "not a SolidCraft drawing (no format)");
+ }
+
+ /// One drawing change pending, as a drawing's first change will be: the build writes format 2
+ /// and names the change in `format_pending`. Its step runs for a drawing without the change and
+ /// never for one with it; a drawing naming a change this build lacks, or of format 3, is a newer
+ /// build's.
+ #[test]
+ fn a_pending_drawing_change_makes_format_two() {
+ use serde_json::json;
+ let pending = [traced("a-first")];
+ let drawing = Family { formats: Formats { hand: &[], folded: &[], pending: &pending }, ..DRAWING };
+ assert_eq!((drawing.current(), drawing.format_string(drawing.current())), (2, "solidcraft-drawing/2".to_string()));
+ assert_eq!(drawing.pending_names(), ["a-first"]);
+ let open = |mut file: Value| -> Result<Vec<String>> {
+ let (version, applied) = drawing.take_version(&mut file)?;
+ assert!(file.get("format_pending").is_none(), "taken out of the JSON before the record is read");
+ drawing.upgrade(&mut file, version, applied.as_deref())?;
+ Ok(trace_of(&file).into_iter().map(str::to_string).collect())
+ };
+ assert_eq!(open(json!({"format": "solidcraft-drawing/1"})).unwrap(), ["a"]);
+ assert_eq!(open(json!({"format": "solidcraft-drawing/2", "format_pending": []})).unwrap(), ["a"]);
+ assert_eq!(open(json!({"format": "solidcraft-drawing/2", "format_pending": ["a-first"]})).unwrap(), Vec::<String>::new());
+ // A list beside format 1 means nothing: the step still runs.
+ assert_eq!(open(json!({"format": "solidcraft-drawing/1", "format_pending": ["c-later"]})).unwrap(), ["a"]);
+ let error = open(json!({"format": "solidcraft-drawing/2", "format_pending": ["a-first", "c-later"]})).unwrap_err().to_string();
+ assert_eq!(
+ error,
+ "this drawing was saved by a newer SolidCraft (file format 2 with `c-later`, which this version doesn't know): update SolidCraft to open it"
+ );
+ let error = open(json!({"format": "solidcraft-drawing/3"})).unwrap_err().to_string();
+ assert_eq!(
+ error,
+ "this drawing was saved by a newer SolidCraft (file format 3; this version reads formats up to 2): update SolidCraft to open it"
+ );
+ // An upgrade called without `take_version` refuses in the drawing's words too, format 0 included.
+ let error = drawing.upgrade(&mut json!({}), 3, None).unwrap_err().to_string();
+ assert!(error.starts_with("this drawing was saved by a newer SolidCraft (file format 3;"), "{error}");
+ assert_eq!(drawing.upgrade(&mut json!({}), 0, None).unwrap_err().to_string(), "not a SolidCraft drawing (format 0)");
+ }
+
/// `format_pending` is read and checked: a damaged list is refused, a list of changes this
/// build doesn't have is a newer build's, and saving writes this build's own list.
#[test]
diff --git a/crates/doc/src/ids.rs b/crates/doc/src/ids.rs
new file mode 100644
index 0000000000..2e741ff2ea
--- /dev/null
+++ b/crates/doc/src/ids.rs
@@ -0,0 +1,195 @@
+//! Object ids (#1017, #3890): random, so objects added side by side, on two branches of a
+//! repository or in two copies of a file, never take the same id, and no counter changes with
+//! every addition. Drawings use them from their first format; designs keep their numbered ids
+//! until they move over too (#626 Phase 3).
+//!
+//! - In memory an id is a nonzero `u64`. 0 is never one (it stands for a design's root
+//! component).
+//! - An [`IdSource`] gives them: splitmix64 from a seed, each draw checked against the ids in
+//! use and drawn again when it is one. [`IdSource::seeded`] gives the same ids for the same
+//! seed, for tests and replays, and still a new one in a file that seed made;
+//! [`IdSource::from_entropy`] is what a session uses.
+//! - In a file an id is 13 characters of Crockford's base32, lowercase: digits and letters without
+//! i, l, o and u, the first `0` to `f` (`0000000000001`, `fzzzzzzzzzzzz`). [`encode`] writes it
+//! and [`decode`] reads only that spelling, so an id has one form in a file's text. A field
+//! holding an id says `#[serde(with = "crate::ids")]`.
+
+use std::collections::BTreeSet;
+use std::collections::hash_map::RandomState;
+use std::hash::BuildHasher;
+use std::sync::atomic::{AtomicU64, Ordering};
+
+use serde::{Deserialize, Deserializer, Serializer};
+
+use crate::{DocError, Result};
+
+/// The characters of an id in a file: 64 bits in 5-bit digits, the first holding the top four.
+pub const ID_CHARS: usize = 13;
+/// Crockford's base32 digits, lowercase.
+const DIGITS: &[u8; 32] = b"0123456789abcdefghjkmnpqrstvwxyz";
+/// splitmix64's step: odd, so the state passes every `u64` before it comes round again.
+const GAMMA: u64 = 0x9e37_79b9_7f4a_7c15;
+
+/// Gives ids from a seed.
+#[derive(Clone, Debug)]
+pub struct IdSource {
+ state: u64,
+}
+
+impl IdSource {
+ /// The same ids for the same seed, for tests and replays.
+ pub fn seeded(seed: u64) -> IdSource {
+ IdSource { state: seed }
+ }
+
+ /// Ids another run gives only by chance: seeded from the standard library's hash keys (random
+ /// where the platform gives it randomness), the time, and a count of sources made, so two
+ /// sources made together differ.
+ pub fn from_entropy() -> IdSource {
+ static MADE: AtomicU64 = AtomicU64::new(0);
+ let nanos = web_time::SystemTime::now().duration_since(web_time::UNIX_EPOCH).map_or(0, |d| d.as_nanos());
+ IdSource::seeded(RandomState::new().hash_one((nanos, MADE.fetch_add(1, Ordering::Relaxed))))
+ }
+
+ /// The next id that isn't 0 and isn't `in_use`. A run never draws a number twice, so at most
+ /// one draw per id in use, and one 0, come before a free one.
+ pub fn next(&mut self, in_use: &BTreeSet<u64>) -> Result<u64> {
+ for _ in 0..in_use.len().saturating_add(2) {
+ let id = self.draw();
+ if id != 0 && !in_use.contains(&id) {
+ return Ok(id);
+ }
+ }
+ Err(DocError::Invalid("no free id".into()))
+ }
+
+ /// splitmix64: its mixing is one-to-one, so a run never gives one number twice.
+ fn draw(&mut self) -> u64 {
+ self.state = self.state.wrapping_add(GAMMA);
+ let mut z = self.state;
+ z = (z ^ (z >> 30)).wrapping_mul(0xbf58_476d_1ce4_e5b9);
+ z = (z ^ (z >> 27)).wrapping_mul(0x94d0_49bb_1331_11eb);
+ z ^ (z >> 31)
+ }
+}
+
+/// `id` as a file writes it: [`ID_CHARS`] base32 digits, the most significant first.
+pub fn encode(id: u64) -> String {
+ (0..ID_CHARS).rev().map(|k| DIGITS.get(((id >> (5 * k)) & 31) as usize).map_or('0', |&d| char::from(d))).collect()
+}
+
+/// The id `text` writes, if it is one in [`encode`]'s spelling: anything else, 0 included, is not.
+pub fn decode(text: &str) -> Option<u64> {
+ if text.len() != ID_CHARS {
+ return None;
+ }
+ // A first digit above `f` overflows the 64 bits.
+ let id = text.bytes().try_fold(0u64, |id, b| id.checked_mul(32)?.checked_add(DIGITS.iter().position(|&d| d == b)? as u64))?;
+ (id != 0).then_some(id)
+}
+
+/// serde's `with` for an id field: written as [`encode`] writes it, read as [`decode`] reads it.
+pub fn serialize<S: Serializer>(id: &u64, s: S) -> std::result::Result<S::Ok, S::Error> {
+ s.serialize_str(&encode(*id))
+}
+
+/// See [`serialize`].
+pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> std::result::Result<u64, D::Error> {
+ let text = String::deserialize(d)?;
+ decode(&text).ok_or_else(|| serde::de::Error::custom(format!("an id is {ID_CHARS} characters of lowercase Crockford base32, not all 0")))
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn none() -> BTreeSet<u64> {
+ BTreeSet::new()
+ }
+
+ /// Every boundary of the spelling: 1, the last value of one digit and the first of two, the
+ /// top digit alone and the largest id, and splitmix64's first output for seed 0.
+ #[test]
+ fn an_id_is_written_as_13_digits_and_read_back() {
+ let pinned = [
+ (1, "0000000000001"),
+ (31, "000000000000z"),
+ (32, "0000000000010"),
+ (1 << 60, "1000000000000"),
+ (u64::MAX, "fzzzzzzzzzzzz"),
+ (0xe220_a839_7b1d_cdaf, "e485875xhvkdf"),
+ ];
+ for (id, text) in pinned {
+ assert_eq!((encode(id), decode(text)), (text.to_string(), Some(id)), "{id:#x}");
+ }
+ let mut source = IdSource::seeded(1);
+ for _ in 0..10_000 {
+ let id = source.next(&none()).unwrap();
+ assert_eq!(decode(&encode(id)), Some(id), "{id:#x}");
+ }
+ }
+
+ /// Only [`encode`]'s spelling is an id: the wrong length, 0, a first digit past `f`, capitals
+ /// (case-sensitive, so an id has one spelling to search for), the letters Crockford leaves
+ /// out, and anything not ASCII.
+ #[test]
+ fn only_the_written_spelling_is_an_id() {
+ let not_ids = [
+ "",
+ "000000000001",
+ "00000000000001",
+ "0000000000000",
+ "g000000000000",
+ "zzzzzzzzzzzzz",
+ "Fzzzzzzzzzzzz",
+ "000000000000A",
+ "000000000000i",
+ "000000000000l",
+ "000000000000o",
+ "000000000000u",
+ "00000000000é",
+ "000000000000-",
+ " 000000000001",
+ "000000000001\n",
+ ];
+ for text in not_ids {
+ assert_eq!(decode(text), None, "{text:?}");
+ }
+ }
+
+ /// A seed gives the same ids every time (splitmix64's published first outputs for seed 0), and
+ /// a run never gives one twice.
+ #[test]
+ fn a_seeded_source_repeats_its_ids_and_never_gives_one_twice() {
+ let mut zero = IdSource::seeded(0);
+ assert_eq!([zero.draw(), zero.draw(), zero.draw()], [0xe220_a839_7b1d_cdaf, 0x6e78_9e6a_a1b9_65f4, 0x06c4_5d18_8009_454f]);
+ let run = |seed| {
+ let mut source = IdSource::seeded(seed);
+ (0..10_000).map(|_| source.next(&none()).unwrap()).collect::<Vec<_>>()
+ };
+ assert_eq!(run(7), run(7));
+ assert_ne!(run(7), run(8));
+ assert_eq!(run(7).into_iter().collect::<BTreeSet<_>>().len(), 10_000);
+ }
+
+ /// A draw that is in use, or 0, is drawn again: a file the same seed made, reopened with that
+ /// seed, collides on every one of its ids in turn and still gets a new one.
+ #[test]
+ fn a_taken_id_or_0_is_drawn_again() {
+ let mut seven = IdSource::seeded(7);
+ let made: Vec<u64> = (0..101).map(|_| seven.draw()).collect();
+ let in_use: BTreeSet<u64> = made.iter().take(100).copied().collect();
+ assert_eq!(IdSource::seeded(7).next(&in_use).unwrap(), made[100]);
+ // The state just before 0's: its first draw is 0, and the next is seed 0's first.
+ let before_zero = 0u64.wrapping_sub(GAMMA);
+ assert_eq!(IdSource::seeded(before_zero).draw(), 0);
+ assert_eq!(IdSource::seeded(before_zero).next(&none()).unwrap(), IdSource::seeded(0).draw());
+ }
+
+ /// Two sources made together still give different ids.
+ #[test]
+ fn sources_from_entropy_differ() {
+ let (mut a, mut b) = (IdSource::from_entropy(), IdSource::from_entropy());
+ assert_ne!(a.next(&none()).unwrap(), b.next(&none()).unwrap());
+ }
+}
diff --git a/crates/doc/src/lib.rs b/crates/doc/src/lib.rs
index 327918ef23..9a5920d312 100644
--- a/crates/doc/src/lib.rs
+++ b/crates/doc/src/lib.rs
@@ -23,6 +23,7 @@ pub mod construct;
pub mod display_quality;
pub mod display_units;
mod document;
+pub mod drawing;
mod eval;
pub mod expr;
pub mod face_anchor;
@@ -34,6 +35,7 @@ mod format_offsets;
pub mod frame;
mod history_names;
pub mod hole_reference;
+pub mod ids;
pub use format_offsets::whole_profile_selection_from_value;
pub mod joints;
mod lineage;
@@ -69,8 +71,8 @@ pub mod sheet;
pub mod text_params;
pub use assembly::{
- IDENTITY, MAX_PLACEMENT_DEPTH, MAX_PLACEMENTS, Mat, Occurrence, WorldNames, apply_point, apply_vector, is_identity, map_point_expr, mat_inverse,
- mat_mul, rigid,
+ BomType, IDENTITY, MAX_PLACEMENT_DEPTH, MAX_PLACEMENTS, Mat, Occurrence, WorldNames, apply_point, apply_vector, is_identity, map_point_expr,
+ mat_inverse, mat_mul, rigid,
};
pub use document::*;
pub use eval::{
diff --git a/crates/doc/src/metadata.rs b/crates/doc/src/metadata.rs
index 5d99c24e61..8e0122b6f3 100644
--- a/crates/doc/src/metadata.rs
+++ b/crates/doc/src/metadata.rs
@@ -6,6 +6,7 @@
//! each may be set (the design, a component or both), how its value is checked and its label.
//! It keeps every other key exactly as it was through open, edit and save. Other tools keep
//! their own data under one reverse-DNS key each (`com.example.tool`), holding an object.
+//! A component's part properties have one more key: its bill of materials type (`bom_type`).
//!
//! Reading never validates: a well-known key holding something other than text is kept as it
//! is and reads as absent, so a file another tool wrote always opens. Writing through
@@ -20,7 +21,7 @@
use serde::{Deserialize, Serialize};
use serde_json::{Map, Value};
-use crate::{DocError, Result};
+use crate::{BomType, DocError, Result};
pub const PROJECT: &str = "project";
pub const PART_NUMBER: &str = "part_number";
@@ -92,6 +93,11 @@ pub static KEYS: &[Key] = &[
/// own, and the Bill of Materials window edits them.
pub static BOM_KEYS: &[&str] = &[PART_NUMBER, DESCRIPTION, REVISION];
+/// A component's [`BomType`] in the bill of materials (one of [`BomType::as_str`]'s words). It is
+/// a part property of a component only, not a row of [`KEYS`], so the Design Properties dialog
+/// doesn't list it and a design refuses it.
+pub const BOM_TYPE: &str = "bom_type";
+
/// Longest key, in bytes.
pub const MAX_KEY_BYTES: usize = 128;
/// Longest well-known text value, in bytes.
@@ -114,9 +120,10 @@ pub fn keys(owner: Owner) -> impl Iterator<Item = &'static Key> {
KEYS.iter().filter(move |k| k.scope.covers(owner))
}
-/// The names of [`keys`]`(owner)`, as refusals list them.
+/// The names of [`keys`]`(owner)`, and a component's [`BOM_TYPE`], as refusals list them.
pub fn key_list(owner: Owner) -> String {
- keys(owner).map(|k| k.name).collect::<Vec<_>>().join(", ")
+ let bom_type = (owner == Owner::Component).then_some(BOM_TYPE);
+ keys(owner).map(|k| k.name).chain(bom_type).collect::<Vec<_>>().join(", ")
}
/// One of SolidCraft's keys, by name.
@@ -126,7 +133,7 @@ pub fn key(name: &str) -> Option<&'static Key> {
/// A key SolidCraft reads as a design or part property.
pub fn is_well_known(name: &str) -> bool {
- key(name).is_some()
+ key(name).is_some() || name == BOM_TYPE
}
/// A reverse-DNS key another tool keeps its data under: two or more dot-separated labels of
@@ -162,6 +169,19 @@ fn text(key: &str, value: Value) -> Result<Option<Value>> {
}
}
+/// The bill of materials type's check: one of [`BomType`]'s words, which empty text (like
+/// `null`) removes, so the component reads as normal again.
+fn bom_type(value: Value) -> Result<Option<Value>> {
+ let Some(word) = text(BOM_TYPE, value)? else { return Ok(None) };
+ let s = word.as_str().unwrap_or_default();
+ if BomType::parse(s).is_none() {
+ let shown: String = s.chars().take(64).collect();
+ let words: Vec<&str> = BomType::ALL.iter().map(|t| t.as_str()).collect();
+ return Err(invalid(format!("`{BOM_TYPE}` is one of {}, not `{shown}`", words.join(", "))));
+ }
+ Ok(Some(word))
+}
+
fn depth(v: &Value) -> usize {
// Iterative, so a hostile value can't overflow the stack here.
let mut deepest = 0;
@@ -223,6 +243,11 @@ impl Metadata {
pub fn license(&self) -> Option<&str> {
self.text(LICENSE)
}
+ /// The component's bill of materials type: normal when the key is missing, or holds a word
+ /// this build doesn't know (a newer SolidCraft's type reads as normal and is kept as it is).
+ pub fn bom_type(&self) -> BomType {
+ self.text(BOM_TYPE).and_then(BomType::parse).unwrap_or_default()
+ }
/// The keys SolidCraft doesn't read (other tools' data, or keys a newer SolidCraft added),
/// kept as they are.
@@ -260,6 +285,9 @@ impl Metadata {
/// `value` as `key` may hold it in `owner`'s metadata (`None`: remove the key), or why it can't.
fn check(owner: Owner, key: &str, value: Value) -> Result<Option<Value>> {
+ if key == BOM_TYPE && owner == Owner::Component {
+ return bom_type(value);
+ }
if let Some(k) = self::key(key).filter(|k| k.scope.covers(owner)) {
return (k.check)(key, value);
}
@@ -333,6 +361,30 @@ mod tests {
assert_eq!(m.0.keys().collect::<Vec<_>>(), ["description"]);
}
+ #[test]
+ fn a_bom_type_takes_one_of_its_words_and_reads_as_normal_otherwise() {
+ let mut m = Metadata::default();
+ assert_eq!(m.bom_type(), BomType::Normal, "no key: normal");
+ for t in BomType::ALL {
+ assert!(m.set(Component, BOM_TYPE, json!(t.as_str())).is_ok(), "{t:?}");
+ assert_eq!(m.bom_type(), t);
+ assert_eq!(BomType::parse(t.as_str()), Some(t));
+ }
+ for bad in [json!("Phantom"), json!("kit"), json!(" phantom"), json!(1), json!({"type": "phantom"}), json!("a\u{7}")] {
+ assert!(m.set(Component, BOM_TYPE, bad.clone()).is_err(), "{bad}");
+ }
+ assert_eq!(m.bom_type(), BomType::Inseparable, "a refused value leaves the old one");
+ assert!(m.set(Component, BOM_TYPE, json!("")).unwrap(), "empty text removes it");
+ assert_eq!(m.bom_type(), BomType::Normal);
+ assert!(m.others().next().is_none(), "SolidCraft reads it, so it isn't another tool's key");
+ // A word a newer build wrote is kept as it is and reads as normal here.
+ let newer: Metadata = serde_json::from_value(json!({"bom_type": "kit"})).unwrap();
+ assert_eq!(newer.bom_type(), BomType::Normal);
+ assert_eq!(newer.get(BOM_TYPE), Some(&json!("kit")));
+ assert!(!keys(Design).any(|k| k.name == BOM_TYPE), "the Design Properties dialog doesn't list it");
+ assert!(Metadata::default().set(Design, BOM_TYPE, json!("phantom")).is_err(), "a design has no bill of materials type");
+ }
+
#[test]
fn the_limits_refuse_growth_but_let_an_oversized_file_shrink() {
let mut m = Metadata::default();
@@ -370,7 +422,7 @@ mod tests {
}
// Every key SolidCraft took on the design and on a component before the table still is.
assert_eq!(key_list(Design), "project, part_number, revision, author, organization, description, license");
- assert_eq!(key_list(Component), key_list(Design));
+ assert_eq!(key_list(Component), format!("{}, {BOM_TYPE}", key_list(Design)), "a component also takes its bill of materials type");
}
#[test]
@@ -402,7 +454,7 @@ mod tests {
assert_eq!(
refusal(Component, "colour"),
"`colour` is not a part property: SolidCraft's are project, part_number, revision, author, organization, \
- description, license; another tool's data goes under a reverse-DNS key such as `com.example.tool`"
+ description, license, bom_type; another tool's data goes under a reverse-DNS key such as `com.example.tool`"
);
for owner in [Design, Component] {
let word = owner.names().0;
diff --git a/crates/doc/src/sheet.rs b/crates/doc/src/sheet.rs
index ed8cf03a3f..d529700f8a 100644
--- a/crates/doc/src/sheet.rs
+++ b/crates/doc/src/sheet.rs
@@ -114,21 +114,6 @@ fn chorded_region(region: &Region2) -> Result<Region2> {
})
}
-/// A line or free-form segment with its points mapped by `f`: exact under any affine map (a
-/// conic keeps its weight). An arc is given by angles, not points, and stays as it is.
-pub(crate) fn map_controls(seg: &Seg2, f: impl Fn(Vec2) -> Vec2) -> Seg2 {
- match *seg {
- Seg2::Line { a, b } => Seg2::Line { a: f(a), b: f(b) },
- Seg2::Cubic { p0, p1, p2, p3 } => Seg2::Cubic { p0: f(p0), p1: f(p1), p2: f(p2), p3: f(p3) },
- Seg2::Conic { a, apex, b, w } => Seg2::Conic { a: f(a), apex: f(apex), b: f(b), w },
- Seg2::Bezier { n, mut p } => {
- p.iter_mut().take(usize::from(n) + 1).for_each(|q| *q = f(*q));
- Seg2::Bezier { n, p }
- }
- arc @ Seg2::Arc { .. } => arc,
- }
-}
-
fn planar_region(region: &Region2) -> Result<Region2> {
if region.holes.len() > MAX_FLAT_PIECES {
return Err(flat_budget_error());
@@ -4315,7 +4300,7 @@ impl SheetBody {
}
}
// Free-form segments map exactly, through their control points.
- other => map_controls(&other, map),
+ other => other.map_controls(map),
}
};
let map_loop = |lp: &Loop2| Loop2 { segs: lp.segs.iter().map(seg).collect() };
@@ -4676,7 +4661,7 @@ fn flip_x_loop(l: &Loop2) -> Loop2 {
Seg2::Arc { center, radius, start, sweep } => {
Seg2::Arc { center: flip_x(center), radius, start: std::f64::consts::PI - start, sweep: -sweep }
}
- other => map_controls(&other, flip_x),
+ other => other.map_controls(flip_x),
})
.collect();
Loop2 { segs }.reversed()
@@ -5325,7 +5310,7 @@ mod tests {
// right: the same ellipse on the sheet, every curve through its mirrored controls.
let below = Plane { origin: Vec3::ZERO, x: Vec3::X, y: Vec3::Y * -1.0 };
let mirror = |p: Vec2| Vec2::new(p.x, -p.y);
- let seen = Region2 { outer: Loop2 { segs: hole.outer.segs.iter().map(|x| map_controls(x, mirror)).collect() }, holes: vec![] };
+ let seen = Region2 { outer: Loop2 { segs: hole.outer.segs.iter().map(|x| x.map_controls(mirror)).collect() }, holes: vec![] };
let mapped = s.region_to_flat(None, &below, &seen).unwrap();
assert!(mapped.outer.is_ccw() && mapped.outer.segs.len() == 4 && mapped.outer.segs.iter().all(|x| hole.outer.segs.contains(x)), "{mapped:?}");
// A cubic and a quartic closed by a line, clockwise in that plane: counter-clockwise on
diff --git a/crates/engine/src/cmd/bom.rs b/crates/engine/src/cmd/bom.rs
index ff5d6cbe8e..e1e5ff7347 100644
--- a/crates/engine/src/cmd/bom.rs
+++ b/crates/engine/src/cmd/bom.rs
@@ -5,11 +5,17 @@
//! `assembly.bom` counts the placed components of the design, or of one component, and lists
//! them as rows, optionally written to a CSV or JSON file. With `group_children`, a part with a
//! part number keeps the parts placed inside it (a bolt's washers and nut) in its own row.
+//!
+//! A component's bill of materials type (`bom_type`, a part property) decides how it counts: a
+//! phantom has no row and what it holds counts in its parent; a reference counts nowhere, and
+//! nothing inside it does; a purchased or inseparable component is one row, and of what an
+//! inseparable one holds only its purchased parts reach the parts-only list.
use std::collections::{BTreeMap, HashSet};
use serde_json::{Map, Value, json};
-use solidcraft_doc::metadata::{BOM_KEYS, MAX_KEYS, Owner, check_text, key_list};
+use solidcraft_doc::BomType;
+use solidcraft_doc::metadata::{BOM_KEYS, BOM_TYPE, MAX_KEYS, Owner, check_text, key_list};
use super::CommandSpec;
use crate::params::{bad, str_};
@@ -18,13 +24,14 @@ use crate::{EngineError, Result, Session};
pub static COMMANDS: &[CommandSpec] = &[
CommandSpec::new("component.metadata", "Part Properties", read).icon("settings").noundo().doc_only().params(
"component: id or name (0 or \"root\": the design's own properties) → component, name, part_number, description, revision, \
- metadata (as saved, other tools' keys too), properties: {name: text}",
+ bom_type (components only), metadata (as saved, other tools' keys too), properties: {name: text}",
),
CommandSpec::new("component.metadata.set", "Change Part Properties", set).icon("settings").doc_only().params(
"component: id or name (not the root: use document.metadata.set); part_number?, description?, revision?: text (empty or null \
- removes); values?: {key: value} (SolidCraft's keys, as document.metadata's properties lists them, or a reverse-DNS key \
- holding an object); properties?: {name: text, …} (free properties; empty or null removes). All or nothing, one undo step \
- → component, metadata, properties, changed: [keys]",
+ removes); bom_type?: normal|phantom|reference|purchased|inseparable (empty or null: normal); values?: {key: value} \
+ (SolidCraft's keys, as document.metadata's properties lists them, bom_type, or a reverse-DNS key holding an object); \
+ properties?: {name: text, …} (free properties; empty or null removes). All or nothing, one undo step → component, \
+ metadata, properties, changed: [keys]",
),
CommandSpec::new("assembly.bom", "Bill of Materials", bom).at("SOLID", "INSPECT").icon("bom").noundo().params(
"component?: id or name (default the design); levels?: flat (default: every part at any depth, counted through its \
@@ -32,8 +39,10 @@ pub static COMMANDS: &[CommandSpec] = &[
(default; components without a part number get a row per definition) | [\"definition\"]; group_children?: true (a component \
with a part number is one row, the parts placed inside it listed under it as children: [{item, part_number, description, \
revision, each, count, definition}], not as rows of their own); path?: write a .csv or .json file (children as items 1.1, \
- 1.2…); format?: csv|json (default from the path) → rows: [{item, part_number, description, revision, count, definition, \
- components, properties, children?}] sorted by part number, total_occurrences (children included)",
+ 1.2…); format?: csv|json (default from the path). Each component's bom_type counts: phantom has no row (what it holds \
+ counts here), reference counts nowhere, purchased and inseparable are one row (in flat, an inseparable one's purchased \
+ parts are listed too) → rows: [{item, part_number, description, revision, bom_type, count, definition, components, \
+ properties, children?}] sorted by part number, total_occurrences (children included)",
),
];
@@ -72,6 +81,10 @@ fn read(s: &mut Session, p: &Value) -> Result<Value> {
for k in BOM_KEYS {
out.insert(k.to_string(), json!(m.text(k)));
}
+ // A bill of materials type is a component's; the design has none.
+ if id != 0 {
+ out.insert(BOM_TYPE.into(), json!(m.bom_type().as_str()));
+ }
out.insert("metadata".into(), json!(m));
out.insert("properties".into(), properties);
Ok(Value::Object(out))
@@ -111,7 +124,7 @@ fn set(s: &mut Session, p: &Value) -> Result<Value> {
Some(Value::Object(_)) => return Err(bad(cmd, format!("`values` can hold at most {MAX_KEYS} keys"))),
Some(_) => return Err(bad(cmd, "`values` must be an object: {key: value, …}")),
}
- for k in BOM_KEYS {
+ for k in BOM_KEYS.iter().chain([&BOM_TYPE]) {
if let Some(v) = p.get(*k) {
entries.push((k.to_string(), v.clone()));
}
@@ -123,7 +136,7 @@ fn set(s: &mut Session, p: &Value) -> Result<Value> {
Some(_) => return Err(bad(cmd, "`properties` must be an object: {name: text, …}")),
};
if entries.is_empty() && props.is_empty() {
- return Err(bad(cmd, format!("give {}, values or properties ({})", BOM_KEYS.join(", "), key_list(Owner::Component))));
+ return Err(bad(cmd, format!("give {}, {BOM_TYPE}, values or properties ({})", BOM_KEYS.join(", "), key_list(Owner::Component))));
}
let mut changed: Vec<String> = Vec::new();
for (k, v) in entries {
@@ -176,6 +189,7 @@ struct Row {
part_number: String,
description: String,
revision: String,
+ bom_type: BomType,
count: u64,
components: Vec<u64>,
names: Vec<String>,
@@ -225,6 +239,8 @@ struct Index {
owners: HashSet<u64>,
/// Components with a part number: with `group_children`, one row however much is inside.
numbered: HashSet<u64>,
+ /// Components whose bill of materials type isn't normal.
+ types: BTreeMap<u64, BomType>,
}
impl Index {
@@ -234,10 +250,24 @@ impl Index {
children.entry(o.parent).or_default().push(o.component);
}
let numbered = s.doc.components.iter().filter(|c| c.metadata.part_number().is_some_and(|n| !n.is_empty())).map(|c| c.id).collect();
- Index { children, owners: s.doc.body_owners(&s.model.state()), numbered }
+ let types = s.doc.components.iter().map(|c| (c.id, c.metadata.bom_type())).filter(|(_, t)| *t != BomType::Normal).collect();
+ Index { children, owners: s.doc.body_owners(&s.model.state()), numbered, types }
+ }
+
+ fn bom_type(&self, component: u64) -> BomType {
+ self.types.get(&component).copied().unwrap_or_default()
}
}
+/// What a walk below a component lists.
+#[derive(Clone, Copy, PartialEq)]
+enum Walk {
+ /// What the bill of materials lists.
+ Listed,
+ /// Inside an inseparable component, in parts only: just its purchased parts.
+ Purchased,
+}
+
fn group_key(g: &str, cmd: &str) -> Result<Group> {
match g {
"part_number" => Ok(Group::PartNumber),
@@ -246,63 +276,88 @@ fn group_key(g: &str, cmd: &str) -> Result<Group> {
}
}
-/// How many times each component is placed below `root`: in `Top`, its direct children; in
-/// `Flat`, every placement at any depth (a part in a subassembly placed twice counts twice),
-/// not below a numbered part when `fold`.
+/// How many times each component is listed below `root`, by its bill of materials type: in
+/// `Top`, the direct children; in `Flat`, the parts at any depth (a part in a subassembly placed
+/// twice counts twice), not below a purchased part, nor below a numbered part when `fold`, and of
+/// what an inseparable part holds only its purchased parts. A phantom's contents count where the
+/// phantom is placed; a reference counts nowhere, and nothing inside it does.
fn counts(ix: &Index, root: u64, levels: Levels, fold: bool, cmd: &str) -> Result<BTreeMap<u64, u64>> {
let mut out: BTreeMap<u64, u64> = BTreeMap::new();
let mut placed = 0usize;
- let mut stack: Vec<(u64, usize)> = vec![(root, 0)];
- while let Some((comp, depth)) = stack.pop() {
+ let mut stack: Vec<(u64, usize, Walk)> = vec![(root, 0, Walk::Listed)];
+ while let Some((comp, depth, walk)) = stack.pop() {
for child in ix.children.get(&comp).into_iter().flatten() {
placed += 1;
if depth >= MAX_DEPTH || placed > MAX_PLACEMENTS {
return Err(bad(cmd, format!("the assembly is deeper than {MAX_DEPTH} levels or has more than {MAX_PLACEMENTS} placements")));
}
- *out.entry(*child).or_default() += 1;
- if levels == Levels::Flat && !(fold && ix.numbered.contains(child)) {
- stack.push((*child, depth + 1));
+ let inside = ix.children.contains_key(child);
+ match (ix.bom_type(*child), walk) {
+ (BomType::Reference, _) => {}
+ (BomType::Phantom, _) => stack.push((*child, depth + 1, walk)),
+ (BomType::Purchased, _) => *out.entry(*child).or_default() += 1,
+ (_, Walk::Purchased) => {
+ if inside {
+ stack.push((*child, depth + 1, Walk::Purchased));
+ }
+ }
+ (BomType::Inseparable, Walk::Listed) => {
+ *out.entry(*child).or_default() += 1;
+ if levels == Levels::Flat && inside {
+ stack.push((*child, depth + 1, Walk::Purchased));
+ }
+ }
+ (BomType::Normal, Walk::Listed) => {
+ // Parts only: a subassembly is listed through its parts, unless it has bodies
+ // of its own (or, folding, a part number).
+ let folded = fold && ix.numbered.contains(child);
+ if levels == Levels::Top || !inside || folded || ix.owners.contains(child) {
+ *out.entry(*child).or_default() += 1;
+ }
+ if levels == Levels::Flat && inside && !folded {
+ stack.push((*child, depth + 1, Walk::Listed));
+ }
+ }
}
}
}
- if levels == Levels::Flat {
- // Parts only: a subassembly is listed through its parts, unless it has bodies of its own
- // (or, folding, a part number).
- out.retain(|c, _| !ix.children.contains_key(c) || (fold && ix.numbered.contains(c)) || ix.owners.contains(c));
- }
Ok(out)
}
-/// How a kit reads when rows are compared: its parts by part number (else definition) and count.
-fn kit_key(s: &Session, kit: &BTreeMap<u64, u64>) -> String {
+/// How a kit reads when rows are compared: its parts by part number (else definition), bill of
+/// materials type and count, so a kit holding a bought bolt isn't the kit holding a made one.
+fn kit_key(s: &Session, ix: &Index, kit: &BTreeMap<u64, u64>) -> String {
let mut parts: Vec<String> = kit
.iter()
.map(|(id, n)| {
let pn = s.doc.components.iter().find(|c| c.id == *id).and_then(|c| c.metadata.part_number()).unwrap_or_default();
- if pn.is_empty() { format!("#{id}×{n}") } else { format!("{pn}×{n}") }
+ let bom_type = ix.bom_type(*id).as_str();
+ if pn.is_empty() { format!("#{id} {bom_type}×{n}") } else { format!("{pn} {bom_type}×{n}") }
})
.collect();
parts.sort();
parts.join("\n")
}
-fn rows(s: &Session, counts: &BTreeMap<u64, u64>, group: Group, kits: &BTreeMap<u64, BTreeMap<u64, u64>>) -> Vec<Row> {
- let mut grouped: BTreeMap<(String, String, u64), Row> = BTreeMap::new();
+fn rows(s: &Session, ix: &Index, counts: &BTreeMap<u64, u64>, group: Group, kits: &BTreeMap<u64, BTreeMap<u64, u64>>) -> Vec<Row> {
+ let mut grouped: BTreeMap<(String, String, u64, BomType), Row> = BTreeMap::new();
for (id, n) in counts {
let Some(c) = s.doc.components.iter().find(|c| c.id == *id) else { continue };
let m = &c.metadata;
let part_number = m.part_number().unwrap_or_default().to_string();
let kit = kits.get(id).cloned().unwrap_or_default();
+ let bom_type = ix.bom_type(*id);
// Without a part number a definition is its own row; parts with different contents
- // (a bolt with or without its nut) are different rows.
+ // (a bolt with or without its nut) or different bill of materials types are different rows.
let k = match group {
- Group::PartNumber if !part_number.is_empty() => (part_number.clone(), kit_key(s, &kit), 0),
- _ => (String::new(), String::new(), *id),
+ Group::PartNumber if !part_number.is_empty() => (part_number.clone(), kit_key(s, ix, &kit), 0, bom_type),
+ _ => (String::new(), String::new(), *id, bom_type),
};
let row = grouped.entry(k).or_insert_with(|| Row {
part_number: part_number.clone(),
description: String::new(),
revision: String::new(),
+ bom_type,
count: 0,
components: Vec::new(),
names: Vec::new(),
@@ -361,10 +416,11 @@ fn bom(s: &mut Session, p: &Value) -> Result<Value> {
let o = options(p, cmd)?;
let ix = Index::new(s);
let counts = counts(&ix, root, o.levels, o.fold, cmd)?;
- // Folding: what one of each numbered part holds, as parts at any depth.
+ // Folding: what one of each numbered part holds, as parts at any depth. A purchased or
+ // inseparable part already keeps what it holds out of the list.
let mut kits: BTreeMap<u64, BTreeMap<u64, u64>> = BTreeMap::new();
if o.fold {
- for id in counts.keys().filter(|id| ix.numbered.contains(id)) {
+ for id in counts.keys().filter(|id| ix.numbered.contains(id) && ix.bom_type(**id) == BomType::Normal) {
let kit = self::counts(&ix, *id, Levels::Flat, false, cmd)?;
if !kit.is_empty() {
kits.insert(*id, kit);
@@ -372,22 +428,24 @@ fn bom(s: &mut Session, p: &Value) -> Result<Value> {
}
}
let mut total: u64 = 0;
- let rows: Vec<Value> = rows(s, &counts, o.group, &kits)
+ let rows: Vec<Value> = rows(s, &ix, &counts, o.group, &kits)
.into_iter()
.enumerate()
.map(|(i, r)| {
total += r.count;
let mut v = json!({"item": i + 1, "part_number": r.part_number, "description": r.description, "revision": r.revision,
- "count": r.count, "definition": r.names.join("; "), "components": r.components, "properties": r.properties});
+ "bom_type": r.bom_type.as_str(), "count": r.count, "definition": r.names.join("; "), "components": r.components,
+ "properties": r.properties});
if !r.kit.is_empty() {
- let children: Vec<Value> = self::rows(s, &r.kit, Group::PartNumber, &BTreeMap::new())
+ let children: Vec<Value> = self::rows(s, &ix, &r.kit, Group::PartNumber, &BTreeMap::new())
.into_iter()
.enumerate()
.map(|(j, c)| {
let count = c.count.saturating_mul(r.count);
total += count;
json!({"item": format!("{}.{}", i + 1, j + 1), "part_number": c.part_number, "description": c.description,
- "revision": c.revision, "each": c.count, "count": count, "definition": c.names.join("; ")})
+ "revision": c.revision, "bom_type": c.bom_type.as_str(), "each": c.count, "count": count,
+ "definition": c.names.join("; ")})
})
.collect();
v["children"] = Value::Array(children);
diff --git a/crates/engine/src/cmd/bom_tests.rs b/crates/engine/src/cmd/bom_tests.rs
index 93e25e9a1f..8dc9f2b150 100644
--- a/crates/engine/src/cmd/bom_tests.rs
+++ b/crates/engine/src/cmd/bom_tests.rs
@@ -267,7 +267,7 @@ fn a_components_refusals_speak_of_part_properties() {
assert!(
bogus.ends_with(
"`bogus` is not a part property: SolidCraft's are project, part_number, revision, author, organization, description, \
- license; another tool's data goes under a reverse-DNS key such as `com.example.tool`"
+ license, bom_type; another tool's data goes under a reverse-DNS key such as `com.example.tool`"
),
"{bogus}"
);
@@ -275,8 +275,8 @@ fn a_components_refusals_speak_of_part_properties() {
assert!(refusal(&mut s, json!({"component": "Pin", "values": {"": "x"}})).contains("`` is not a part property"));
// Nothing to change: the same list as before the table.
assert!(refusal(&mut s, json!({"component": "Pin"})).ends_with(
- "give part_number, description, revision, values or properties (project, part_number, revision, author, organization, \
- description, license)"
+ "give part_number, description, revision, bom_type, values or properties (project, part_number, revision, author, \
+ organization, description, license, bom_type)"
));
// Only the bill of materials' keys are parameters of their own; the others go in `values`.
assert!(refusal(&mut s, json!({"component": "Pin", "author": "Jane"})).contains("give part_number, description, revision"));
@@ -400,3 +400,227 @@ fn body_owners_match_each_bodys_component() {
assert_eq!(s.doc.model_body_components(&st), in_order);
}
}
+
+/// A machine: a plate, and a gearbox (no bodies of its own) that holds a shaft and a bearing.
+/// Each is placed once.
+fn machine() -> Session {
+ let mut s = Session::default();
+ run(&mut s, "component.create", json!({"name": "Plate"}));
+ run(&mut s, "solid.box", json!({"length": 100, "width": 60, "height": 10}));
+ run(&mut s, "component.activate", json!({"component": 0}));
+ run(&mut s, "component.create", json!({"name": "Gearbox", "activate": false}));
+ for (name, diameter, height) in [("Shaft", 10, 80), ("Bearing", 22, 7)] {
+ run(&mut s, "component.create", json!({"name": name, "parent": "Gearbox"}));
+ run(&mut s, "solid.cylinder", json!({"diameter": diameter, "height": height}));
+ run(&mut s, "component.activate", json!({"component": 0}));
+ }
+ for (c, pn) in [("Plate", "PL-1"), ("Gearbox", "GB-1"), ("Shaft", "SH-1"), ("Bearing", "BR-1")] {
+ run(&mut s, "component.metadata.set", json!({"component": c, "part_number": pn}));
+ }
+ s
+}
+
+/// Each row's part number, bill of materials type and count.
+fn typed(r: &Value) -> Vec<(String, String, u64)> {
+ r["rows"]
+ .as_array()
+ .unwrap()
+ .iter()
+ .map(|r| (r["part_number"].as_str().unwrap().to_string(), r["bom_type"].as_str().unwrap().to_string(), r["count"].as_u64().unwrap()))
+ .collect()
+}
+
+fn row(part_number: &str, bom_type: &str, count: u64) -> (String, String, u64) {
+ (part_number.to_string(), bom_type.to_string(), count)
+}
+
+fn set_type(s: &mut Session, component: &str, bom_type: &str) {
+ run(s, "component.metadata.set", json!({"component": component, "bom_type": bom_type}));
+}
+
+#[test]
+fn bom_types_decide_what_is_a_row_and_what_counts_inside_it() {
+ let mut s = machine();
+ let top = |s: &mut Session| typed(&run(s, "assembly.bom", json!({"levels": "top"})));
+ let flat = |s: &mut Session| typed(&run(s, "assembly.bom", json!({})));
+ let own = |s: &mut Session| typed(&run(s, "assembly.bom", json!({"component": "Gearbox"})));
+ // Normal: the gearbox is a row at the top and is listed through its parts in parts only.
+ assert_eq!(top(&mut s), [row("GB-1", "normal", 1), row("PL-1", "normal", 1)]);
+ assert_eq!(flat(&mut s), [row("BR-1", "normal", 1), row("PL-1", "normal", 1), row("SH-1", "normal", 1)]);
+
+ // Purchased: one row, with nothing inside it listed; its own bill of materials still lists it.
+ set_type(&mut s, "Gearbox", "purchased");
+ assert_eq!(top(&mut s), [row("GB-1", "purchased", 1), row("PL-1", "normal", 1)]);
+ assert_eq!(flat(&mut s), [row("GB-1", "purchased", 1), row("PL-1", "normal", 1)]);
+ assert_eq!(own(&mut s), [row("BR-1", "normal", 1), row("SH-1", "normal", 1)]);
+
+ // Inseparable: one row; of what it holds only purchased parts reach the parts-only list.
+ set_type(&mut s, "Gearbox", "inseparable");
+ assert_eq!(flat(&mut s), [row("GB-1", "inseparable", 1), row("PL-1", "normal", 1)]);
+ set_type(&mut s, "Bearing", "purchased");
+ assert_eq!(top(&mut s), [row("GB-1", "inseparable", 1), row("PL-1", "normal", 1)]);
+ assert_eq!(flat(&mut s), [row("BR-1", "purchased", 1), row("GB-1", "inseparable", 1), row("PL-1", "normal", 1)]);
+ assert_eq!(own(&mut s), [row("BR-1", "purchased", 1), row("SH-1", "normal", 1)], "in its own context an ordinary assembly");
+
+ // Reference: counted nowhere, and nothing inside it is counted, purchased parts included.
+ set_type(&mut s, "Gearbox", "reference");
+ assert_eq!(top(&mut s), [row("PL-1", "normal", 1)]);
+ assert_eq!(flat(&mut s), [row("PL-1", "normal", 1)]);
+ assert_eq!(run(&mut s, "assembly.bom", json!({}))["total_occurrences"], 1);
+
+ // Phantom: no row; what it holds counts where it is placed, at the top level too.
+ set_type(&mut s, "Gearbox", "phantom");
+ assert_eq!(top(&mut s), [row("BR-1", "purchased", 1), row("PL-1", "normal", 1), row("SH-1", "normal", 1)]);
+ assert_eq!(flat(&mut s), [row("BR-1", "purchased", 1), row("PL-1", "normal", 1), row("SH-1", "normal", 1)]);
+
+ // Back to normal (empty text removes the key) gives the first lists again.
+ set_type(&mut s, "Gearbox", "");
+ set_type(&mut s, "Bearing", "normal");
+ assert_eq!(top(&mut s), [row("GB-1", "normal", 1), row("PL-1", "normal", 1)]);
+ assert_eq!(flat(&mut s), [row("BR-1", "normal", 1), row("PL-1", "normal", 1), row("SH-1", "normal", 1)]);
+ assert_eq!(run(&mut s, "component.metadata", json!({"component": "Gearbox"}))["bom_type"], "normal");
+}
+
+#[test]
+fn a_phantom_counts_what_it_holds_in_its_parent_merged_with_the_same_parts() {
+ // A fastener set (no bodies) of two screws, placed three times, and one more screw placed directly.
+ let mut s = Session::default();
+ run(&mut s, "component.create", json!({"name": "Set", "activate": false}));
+ run(&mut s, "component.create", json!({"name": "Screw", "parent": "Set"}));
+ run(&mut s, "solid.cylinder", json!({"diameter": 6, "height": 20}));
+ run(&mut s, "component.activate", json!({"component": 0}));
+ run(&mut s, "occurrence.copy", json!({"component": "Screw", "parent": "Set", "translate": [10, 0, 0]}));
+ for y in [50, 100] {
+ run(&mut s, "occurrence.copy", json!({"component": "Set", "translate": [0, y, 0]}));
+ }
+ run(&mut s, "occurrence.copy", json!({"component": "Screw", "parent": 0, "translate": [0, -50, 0]}));
+ run(&mut s, "component.metadata.set", json!({"component": "Screw", "part_number": "SC-6"}));
+ run(&mut s, "component.metadata.set", json!({"component": "Set", "part_number": "SET-1"}));
+ assert_eq!(typed(&run(&mut s, "assembly.bom", json!({"levels": "top"}))), [row("SC-6", "normal", 1), row("SET-1", "normal", 3)]);
+ assert_eq!(typed(&run(&mut s, "assembly.bom", json!({}))), [row("SC-6", "normal", 7)], "2 x 3 + 1");
+
+ set_type(&mut s, "Set", "phantom");
+ assert_eq!(typed(&run(&mut s, "assembly.bom", json!({"levels": "top"}))), [row("SC-6", "normal", 7)], "promoted and merged");
+ let flat = run(&mut s, "assembly.bom", json!({}));
+ assert_eq!(typed(&flat), [row("SC-6", "normal", 7)]);
+ assert_eq!(flat["total_occurrences"], 7);
+
+ // A phantom inside a phantom promotes through both.
+ run(&mut s, "component.create", json!({"name": "Kit", "activate": false}));
+ run(&mut s, "occurrence.copy", json!({"component": "Set", "parent": "Kit"}));
+ run(&mut s, "occurrence.copy", json!({"component": "Kit", "translate": [0, 200, 0]}));
+ set_type(&mut s, "Kit", "phantom");
+ // The Kit created at the root holds one Set; its copy holds the same: 2 kits x 2 screws more.
+ assert_eq!(typed(&run(&mut s, "assembly.bom", json!({"levels": "top"}))), [row("SC-6", "normal", 11)]);
+}
+
+/// Kits with one part number fold into one row only when what they hold is the same, its bill of
+/// materials types included: a kit holding a bought bolt isn't the kit holding a made one.
+#[test]
+fn kits_with_one_part_number_fold_together_only_when_their_contents_types_match() {
+ let mut s = Session::default();
+ for (kit, bolt) in [("KitA", "BoltA"), ("KitB", "BoltB")] {
+ run(&mut s, "component.create", json!({"name": kit, "activate": false}));
+ run(&mut s, "component.create", json!({"name": bolt, "parent": kit}));
+ run(&mut s, "solid.cylinder", json!({"diameter": 6, "height": 20}));
+ run(&mut s, "component.activate", json!({"component": 0}));
+ run(&mut s, "component.metadata.set", json!({"component": kit, "part_number": "KIT"}));
+ run(&mut s, "component.metadata.set", json!({"component": bolt, "part_number": "BOLT"}));
+ }
+ // Each kit row: its count, and each child's definition, count in one kit and count in all.
+ let kits = |s: &mut Session| -> Vec<(u64, Vec<(String, u64, u64)>)> {
+ let r = run(s, "assembly.bom", json!({"group_children": true}));
+ let child = |c: &Value| (c["definition"].as_str().unwrap().to_string(), c["each"].as_u64().unwrap(), c["count"].as_u64().unwrap());
+ r["rows"]
+ .as_array()
+ .unwrap()
+ .iter()
+ .map(|k| (k["count"].as_u64().unwrap(), k["children"].as_array().unwrap().iter().map(child).collect()))
+ .collect()
+ };
+ let same = kits(&mut s);
+ assert_eq!((same.len(), same[0].0, same[0].1.len(), same[0].1[0].1, same[0].1[0].2), (1, 2, 1, 1, 2), "{same:?}");
+ set_type(&mut s, "BoltB", "purchased");
+ assert_eq!(kits(&mut s), [(1, vec![("BoltA".into(), 1, 1)]), (1, vec![("BoltB".into(), 1, 1)])]);
+}
+
+#[test]
+fn a_purchased_part_keeps_what_is_placed_inside_it_out_of_the_list() {
+ let mut s = bolts();
+ // Each inserted bolt is a definition of its own; buy them all.
+ let bolts = run(&mut s, "assembly.bom", json!({}))["rows"][0]["components"].clone();
+ assert_eq!(bolts.as_array().map(Vec::len), Some(3));
+ for bolt in bolts.as_array().unwrap() {
+ run(&mut s, "component.metadata.set", json!({"component": bolt, "bom_type": "purchased"}));
+ }
+ // The washers and nuts placed inside two of them are no longer listed.
+ let plain = run(&mut s, "assembly.bom", json!({}));
+ assert_eq!(typed(&plain), [row("ISO 4017 M6x30", "purchased", 3)], "{plain}");
+ assert_eq!(plain["total_occurrences"], 3);
+ // Folding has nothing to fold: a purchased part is one row already.
+ let folded = run(&mut s, "assembly.bom", json!({"group_children": true}));
+ assert_eq!(typed(&folded), [row("ISO 4017 M6x30", "purchased", 3)]);
+ assert!(folded["rows"][0].get("children").is_none(), "{folded}");
+ // One bolt bought and two made gives two rows for the one part number.
+ run(&mut s, "component.metadata.set", json!({"component": bolts[0], "bom_type": null}));
+ run(&mut s, "component.metadata.set", json!({"component": bolts[1], "bom_type": null}));
+ let mixed = typed(&run(&mut s, "assembly.bom", json!({})));
+ assert!(mixed.contains(&row("ISO 4017 M6x30", "normal", 2)) && mixed.contains(&row("ISO 4017 M6x30", "purchased", 1)), "{mixed:?}");
+}
+
+#[test]
+fn a_bom_type_is_one_undo_step_survives_save_and_open_and_evaluates_nothing() {
+ let dir = scratch("bom-type");
+ let mut s = machine();
+ let undo = s.undo.len();
+ s.evaluations = 0;
+ let r = run(&mut s, "component.metadata.set", json!({"component": "Gearbox", "bom_type": "inseparable"}));
+ assert_eq!(r["changed"], json!(["bom_type"]));
+ assert_eq!(s.undo.len(), undo + 1);
+ assert_eq!(s.evaluations, 0, "a part property changes no geometry");
+ for (file, format) in [("machine.json", "json"), ("machine.solidcraft", "container")] {
+ let path = dir.join(file);
+ run(&mut s, "file.save_as", json!({"path": path, "format": format}));
+ let mut back = Session::default();
+ run(&mut back, "doc.open", json!({"path": path}));
+ assert_eq!(run(&mut back, "component.metadata", json!({"component": "Gearbox"}))["bom_type"], "inseparable", "{format}");
+ assert_eq!(typed(&run(&mut back, "assembly.bom", json!({}))), typed(&run(&mut s, "assembly.bom", json!({}))), "{format}");
+ }
+ run(&mut s, "edit.undo", json!({}));
+ assert_eq!(run(&mut s, "component.metadata", json!({"component": "Gearbox"}))["bom_type"], "normal");
+ // Through `values` too, and the same word again changes nothing.
+ run(&mut s, "component.metadata.set", json!({"component": "Gearbox", "values": {"bom_type": "phantom"}}));
+ let again = run(&mut s, "component.metadata.set", json!({"component": "Gearbox", "bom_type": "phantom"}));
+ assert_eq!(again["changed"], json!([]));
+ let _ = std::fs::remove_dir_all(&dir);
+}
+
+#[test]
+fn hostile_bom_types_are_refused_without_a_change() {
+ let mut s = machine();
+ let undo = s.undo.len();
+ for p in [
+ json!({"component": "Gearbox", "bom_type": "virtual"}),
+ json!({"component": "Gearbox", "bom_type": "Phantom"}),
+ json!({"component": "Gearbox", "bom_type": 3}),
+ json!({"component": "Gearbox", "bom_type": ["phantom"]}),
+ json!({"component": "Gearbox", "bom_type": "x".repeat(5000)}),
+ json!({"component": "Gearbox", "values": {"bom_type": "phantom\u{7}"}}),
+ json!({"component": 0, "bom_type": "phantom"}),
+ json!({"component": "Gearbox", "part_number": "GB-2", "bom_type": "nope"}),
+ ] {
+ assert!(s.execute("component.metadata.set", &p).is_err(), "{p}");
+ }
+ assert!(s.execute("document.metadata.set", &json!({"key": "bom_type", "value": "phantom"})).is_err(), "not a design property");
+ assert!(s.execute("document.metadata.set", &json!({"values": {"bom_type": "purchased"}})).is_err());
+ assert_eq!(s.undo.len(), undo, "nothing changed");
+ let gb = run(&mut s, "component.metadata", json!({"component": "Gearbox"}));
+ assert_eq!((gb["part_number"].as_str(), gb["bom_type"].as_str()), (Some("GB-1"), Some("normal")), "all or nothing");
+ // A word another build wrote is kept and reads as normal.
+ let id = s.doc.find_component("Gearbox").unwrap();
+ if let Some(c) = s.doc_mut().components.iter_mut().find(|c| c.id == id) {
+ c.metadata.0.insert("bom_type".into(), json!("kit"));
+ }
+ assert_eq!(run(&mut s, "component.metadata", json!({"component": "Gearbox"}))["bom_type"], "normal");
+ assert_eq!(typed(&run(&mut s, "assembly.bom", json!({"levels": "top"}))), [row("GB-1", "normal", 1), row("PL-1", "normal", 1)]);
+}
diff --git a/crates/engine/src/cmd/metadata.rs b/crates/engine/src/cmd/metadata.rs
index d510d051d6..96e5d37606 100644
--- a/crates/engine/src/cmd/metadata.rs
+++ b/crates/engine/src/cmd/metadata.rs
@@ -6,7 +6,7 @@
//! nothing: properties are no geometry.
use serde_json::{Map, Value, json};
-use solidcraft_doc::metadata::{self, MAX_KEYS, Owner};
+use solidcraft_doc::metadata::{self, BOM_TYPE, MAX_KEYS, Owner};
use super::CommandSpec;
use crate::params::{bad, str_};
@@ -49,6 +49,9 @@ fn set(s: &mut Session, p: &Value) -> Result<Value> {
let mut next = s.doc.metadata.clone();
let mut changed = Vec::new();
for (key, value) in entries {
+ if key == BOM_TYPE {
+ return Err(bad(cmd, "`bom_type` is a component's part property: set it with component.metadata.set"));
+ }
if next.set(Owner::Design, key, value.clone()).map_err(|e| bad(cmd, e.to_string()))? {
changed.push(key.to_string());
}
diff --git a/crates/geom/src/aabb2.rs b/crates/geom/src/aabb2.rs
index 8726d24a98..2cf9a8749b 100644
--- a/crates/geom/src/aabb2.rs
+++ b/crates/geom/src/aabb2.rs
@@ -57,6 +57,10 @@ impl Aabb2 {
pub fn contains(&self, p: Vec2) -> bool {
p.x >= self.min.x && p.y >= self.min.y && p.x <= self.max.x && p.y <= self.max.y
}
+ /// The box both hold: empty when they do not meet.
+ pub fn intersection(&self, o: &Aabb2) -> Aabb2 {
+ Aabb2 { min: Vec2::new(self.min.x.max(o.min.x), self.min.y.max(o.min.y)), max: Vec2::new(self.max.x.min(o.max.x), self.max.y.min(o.max.y)) }
+ }
/// Whether the two boxes share a point (never when either is empty).
pub fn meets(&self, o: &Aabb2) -> bool {
self.min.x <= o.max.x && o.min.x <= self.max.x && self.min.y <= o.max.y && o.min.y <= self.max.y
diff --git a/crates/geom/src/cell.rs b/crates/geom/src/cell.rs
new file mode 100644
index 0000000000..04b8a14488
--- /dev/null
+++ b/crates/geom/src/cell.rs
@@ -0,0 +1,254 @@
+//! Cell content: what a cell shows, as text and fields, how it should fit, and the cell text rule
+//! that places a label and a value in a cell. These are the rules every table of cells shares:
+//! title blocks now, parts lists later. Plain data in sheet millimetres, like
+//! [`crate::drawing_sheet`]: nothing here reads a field's value, measures text or draws.
+//!
+//! - [`Content`] is a list of [`Part`]s: text as written, or a field naming a value by its
+//! [`Source`] and key, with a [`Format`]. Keys, units and decimals are kept as written; the
+//! resolver checks them against each source. [`Content::validate`] bounds its size, and
+//! [`check_label`] a label's.
+//! - A value is never cut: when it has more than its [`Fit`] allows, it is shown whole with a
+//! [`Warning`].
+//!
+//! The cell text rule (x to the right, y up), in the cell inside its lines, so the padding is
+//! measured from a line's inner edge whatever the line's width:
+//! - a label's baseline starts [`PADDING_MM`] in from the cell's left side, and its cap height
+//! plus [`PADDING_MM`] down from the cell's top ([`label_at`]);
+//! - the value box is the cell inset by [`PADDING_MM`], its top [`PADDING_MM`] below the label's
+//! baseline when there is a label ([`value_box`]);
+//! - one line of a value that doesn't wrap is centred top to bottom in the value box; otherwise the
+//! lines run down from the box's top at the font's line pitch, the first baseline a cap height
+//! below it ([`place_lines`]). Each baseline stays in the box, and its descenders
+//! ([`DESCENDER_OF_CAP`]) may reach into the padding under it but never past it to a line;
+//! - a line's anchor is on its baseline, at the box's left side, middle or right side: a writer
+//! aligns the line on it.
+//!
+//! Breaking a value into lines that fit the box's width, and warning about width, need the text
+//! measured: they come with the paper scene's text.
+
+use serde::{Deserialize, Serialize};
+
+use crate::paper::MAX_COORDINATE_MM;
+use crate::{Aabb2, EPS, Vec2};
+
+/// The most parts a cell's content may have.
+pub const MAX_PARTS: usize = 64;
+/// The most bytes of text a cell's content may hold in all, and a label.
+pub const MAX_TEXT_BYTES: usize = 4096;
+/// The space between the inner edge of a cell's lines and its text, in millimetres.
+pub const PADDING_MM: f64 = 1.0;
+/// How far a line's descenders reach below its baseline, as a share of its cap height: ISO 3098's
+/// lettering B, whose lower-case tails are 3/10 of the capitals' height. They may reach into the
+/// padding under a value box, never past it.
+pub const DESCENDER_OF_CAP: f64 = 0.3;
+
+/// Where a field's value comes from.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum Source {
+ /// The component the sheet documents.
+ Component,
+ /// The drawing.
+ Drawing,
+ /// The sheet the cell is on.
+ Sheet,
+ /// The drawing's newest revision.
+ Revision,
+ /// An answer given when the block was placed.
+ Prompt,
+}
+
+/// One part of a cell's content. Externally tagged: `{"text": "Sheet "}`,
+/// `{"field": {"source": "sheet", "key": "number"}}`.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case", deny_unknown_fields)]
+pub enum Part {
+ /// Text shown as written.
+ Text(String),
+ /// The value `source` holds under `key` (such as `component` `mass`), shown by `format`.
+ Field {
+ source: Source,
+ key: String,
+ #[serde(default)]
+ format: Format,
+ },
+}
+
+/// How a field's number is shown; what isn't given comes from the caller's settings.
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct Format {
+ pub unit: Option<String>,
+ pub decimals: Option<u8>,
+}
+
+/// What a cell shows: its parts in order.
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+pub struct Content(pub Vec<Part>);
+
+/// What a value should fit beyond its box.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct Fit {
+ /// The most characters a value should have, line breaks not counted.
+ pub max_chars: Option<u32>,
+ /// The most for a value with a wide character (Chinese, Japanese, Korean or Yi), when it
+ /// differs from `max_chars`.
+ pub wide_max_chars: Option<u32>,
+ /// The value breaks between words to fit the box's width, its lines running down from the top.
+ #[serde(default)]
+ pub wrap: bool,
+}
+
+/// Where a line sits across its box.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum HAlign {
+ #[default]
+ Left,
+ Centre,
+ Right,
+}
+
+/// The projection a drawing's views use, first or third angle (ISO 5456-2): the value of
+/// `drawing.projection`, which the views and the title block's symbol both read.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum Projection {
+ First,
+ Third,
+}
+
+/// What doesn't fit, when a value is shown whole.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Warning {
+ /// More characters than the fit allows.
+ Chars { count: usize, max: u32 },
+ /// More lines than the value box holds.
+ Height,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
+#[error("cell: {0}")]
+pub struct Invalid(pub &'static str);
+
+type Result<T> = std::result::Result<T, Invalid>;
+
+fn require(condition: bool, message: &'static str) -> Result<()> {
+ if condition { Ok(()) } else { Err(Invalid(message)) }
+}
+
+/// Checks text by the module's rule: at most [`MAX_TEXT_BYTES`] in all, and no control character
+/// but a line break.
+fn check_text<'a>(texts: impl IntoIterator<Item = &'a str>) -> Result<()> {
+ let mut bytes = 0usize;
+ for text in texts {
+ bytes = bytes.saturating_add(text.len());
+ require(bytes <= MAX_TEXT_BYTES, "a cell's text is at most 4096 bytes")?;
+ require(!text.chars().any(|c| c.is_control() && c != '\n'), "a cell's text has no control character but a line break")?;
+ }
+ Ok(())
+}
+
+impl Part {
+ /// Its text, or its key and unit.
+ fn texts(&self) -> impl Iterator<Item = &str> {
+ let (first, unit) = match self {
+ Part::Text(text) => (text.as_str(), None),
+ Part::Field { key, format, .. } => (key.as_str(), format.unit.as_deref()),
+ };
+ std::iter::once(first).chain(unit)
+ }
+}
+
+impl Content {
+ /// Checks the content's size: at most [`MAX_PARTS`] parts, counted first, and its text, keys
+ /// and units by the module's text rule.
+ pub fn validate(&self) -> Result<()> {
+ require(self.0.len() <= MAX_PARTS, "a cell has at most 64 parts")?;
+ check_text(self.0.iter().flat_map(Part::texts))
+ }
+}
+
+/// Checks a label's text: one line of at most [`MAX_TEXT_BYTES`], without control characters.
+pub fn check_label(text: &str) -> Result<()> {
+ require(text.len() <= MAX_TEXT_BYTES && !text.chars().any(char::is_control), "a label is one line of at most 4096 bytes")
+}
+
+impl Fit {
+ /// [`Warning::Chars`] when `text` has more characters than the fit allows. A text with a wide
+ /// character is held to `wide_max_chars` when it is given.
+ pub fn warn_chars(&self, text: &str) -> Option<Warning> {
+ let wide = text.chars().any(is_wide);
+ let max = if wide { self.wide_max_chars.or(self.max_chars) } else { self.max_chars }?;
+ let count = text.chars().filter(|&c| c != '\n').count();
+ (count > max as usize).then_some(Warning::Chars { count, max })
+ }
+}
+
+/// The Unicode blocks of the scripts written in wide characters (Chinese, Japanese, Korean and Yi),
+/// with their full-width and vertical forms.
+const WIDE: [(u32, u32); 15] = [
+ (0x1100, 0x115F),
+ (0x2E80, 0x303E),
+ (0x3041, 0x33FF),
+ (0x3400, 0x4DBF),
+ (0x4E00, 0x9FFF),
+ (0xA000, 0xA4CF),
+ (0xA960, 0xA97F),
+ (0xAC00, 0xD7A3),
+ (0xF900, 0xFAFF),
+ (0xFE10, 0xFE19),
+ (0xFE30, 0xFE6F),
+ (0xFF00, 0xFF60),
+ (0xFFE0, 0xFFE6),
+ (0x20000, 0x2FFFD),
+ (0x30000, 0x3FFFD),
+];
+
+fn is_wide(c: char) -> bool {
+ let c = u32::from(c);
+ WIDE.iter().any(|&(first, last)| (first..=last).contains(&c))
+}
+
+/// Where a label `cap_mm` high goes in `cell` (the cell inside its lines): its baseline's left end.
+pub fn label_at(cell: Aabb2, cap_mm: f64) -> Vec2 {
+ Vec2::new(cell.min.x + PADDING_MM, cell.max.y - PADDING_MM - cap_mm)
+}
+
+/// The box a cell's value goes in, under a label `label_cap_mm` high when it has one (`cell`: the
+/// cell inside its lines).
+pub fn value_box(cell: Aabb2, label_cap_mm: Option<f64>) -> Aabb2 {
+ let inset = cell.inflated(-PADDING_MM);
+ match label_cap_mm {
+ Some(cap_mm) => Aabb2 { max: Vec2::new(inset.max.x, label_at(cell, cap_mm).y - PADDING_MM), ..inset },
+ None => inset,
+ }
+}
+
+/// Where `lines` lines `cap_mm` high go in `value_box`, `pitch_mm` apart, by the module's rule:
+/// the first line's anchor, each next line `pitch_mm` below the one before, and
+/// [`Warning::Height`] when the last baseline is below the box or its descenders below the padding
+/// under it. The box lies within the paper's coordinates ([`MAX_COORDINATE_MM`]), so the anchor is
+/// always finite.
+pub fn place_lines(value_box: Aabb2, lines: usize, cap_mm: f64, pitch_mm: f64, align: HAlign, wrap: bool) -> Result<(Vec2, Option<Warning>)> {
+ let Aabb2 { min, max } = value_box;
+ let on_paper = [min.x, min.y, max.x, max.y].into_iter().all(|v| v.abs() <= MAX_COORDINATE_MM);
+ require(on_paper && min.x <= max.x && min.y <= max.y, "a value box is not inside out and lies within the paper's coordinates")?;
+ require([cap_mm, pitch_mm].into_iter().all(|v| v.is_finite() && v > 0.0), "a cap height and a line pitch are finite and above 0")?;
+ let x = match align {
+ HAlign::Left => min.x,
+ HAlign::Centre => value_box.center().x,
+ HAlign::Right => max.x,
+ };
+ let y = if lines == 1 && !wrap { value_box.center().y - cap_mm / 2.0 } else { max.y - cap_mm };
+ let last = y - lines.saturating_sub(1) as f64 * pitch_mm;
+ // How far above the box's bottom the last baseline must be for its descenders to stay in the padding.
+ let reach = (cap_mm * DESCENDER_OF_CAP - PADDING_MM).max(0.0);
+ let overflows = lines > 0 && last - reach < min.y - EPS;
+ Ok((Vec2::new(x, y), overflows.then_some(Warning::Height)))
+}
+
+#[cfg(test)]
+#[path = "cell_tests.rs"]
+mod tests;
diff --git a/crates/geom/src/cell_tests.rs b/crates/geom/src/cell_tests.rs
new file mode 100644
index 0000000000..583e3b5549
--- /dev/null
+++ b/crates/geom/src/cell_tests.rs
@@ -0,0 +1,345 @@
+use serde_json::json;
+
+use super::*;
+use crate::bspline::tests::Lcg;
+
+fn rect(x0: f64, y0: f64, x1: f64, y1: f64) -> Aabb2 {
+ Aabb2 { min: Vec2::new(x0, y0), max: Vec2::new(x1, y1) }
+}
+
+fn text(s: &str) -> Part {
+ Part::Text(s.to_string())
+}
+
+fn field(source: Source, key: &str) -> Part {
+ Part::Field { source, key: key.to_string(), format: Format::default() }
+}
+
+/// The title cell's value box on an A3 sheet: the cell (230, 10)-(342, 24) under a 2.5 mm label.
+const TITLE_BOX: Aabb2 = Aabb2 { min: Vec2::new(231.0, 11.0), max: Vec2::new(341.0, 19.5) };
+
+#[test]
+fn the_label_and_the_value_box_inset_the_cell_by_the_padding() {
+ let cell = rect(230.0, 10.0, 342.0, 24.0);
+ // The label's baseline 1 + 2.5 mm below the top; the value box's top 1 mm below that.
+ assert_eq!(label_at(cell, 2.5), Vec2::new(231.0, 20.5));
+ assert_eq!(value_box(cell, Some(2.5)), TITLE_BOX);
+ assert_eq!(value_box(cell, None), rect(231.0, 11.0, 341.0, 23.0));
+}
+
+#[test]
+fn one_line_sits_centred_in_its_value_box_at_the_left_middle_or_right() {
+ // The box's centre is 15.25 high: the 5 mm line's baseline 2.5 below it.
+ for (align, x) in [(HAlign::Left, 231.0), (HAlign::Centre, 286.0), (HAlign::Right, 341.0)] {
+ assert_eq!(place_lines(TITLE_BOX, 1, 5.0, 8.0, align, false), Ok((Vec2::new(x, 12.75), None)), "{align:?}");
+ }
+}
+
+#[test]
+fn wrapped_lines_and_several_lines_run_down_from_the_top_at_the_pitch() {
+ let square = rect(0.0, 0.0, 10.0, 10.0);
+ // A fake font's pitch of 1.6 cap heights: at 2.5 mm the baselines are 2.5 and 6.5 below the top.
+ let (first, warning) = place_lines(square, 2, 2.5, 4.0, HAlign::Left, true).unwrap();
+ assert_eq!((first, warning), (Vec2::new(0.0, 7.5), None));
+ assert_eq!(first.y - 4.0, 10.0 - 6.5);
+ // Two lines without wrapping start at the top too; one line that wraps isn't centred.
+ assert_eq!(place_lines(square, 2, 2.5, 4.0, HAlign::Left, false), Ok((Vec2::new(0.0, 7.5), None)));
+ assert_eq!(place_lines(square, 1, 2.5, 4.0, HAlign::Right, true), Ok((Vec2::new(10.0, 7.5), None)));
+ assert_eq!(place_lines(square, 1, 2.5, 4.0, HAlign::Right, false), Ok((Vec2::new(10.0, 3.75), None)));
+}
+
+#[test]
+fn lines_below_the_box_or_with_descenders_past_its_padding_warn_height() {
+ // 14.5 mm high: four lines at 2.5 and a pitch of 4 end exactly on the bottom; a fifth doesn't fit.
+ let tall = rect(311.0, 45.0, 379.0, 59.5);
+ for wrap in [false, true] {
+ assert_eq!(place_lines(tall, 4, 2.5, 4.0, HAlign::Left, wrap), Ok((Vec2::new(311.0, 57.0), None)));
+ assert_eq!(place_lines(tall, 5, 2.5, 4.0, HAlign::Left, wrap), Ok((Vec2::new(311.0, 57.0), Some(Warning::Height))));
+ }
+ // Within 1e-9 mm of the bottom is on it.
+ let raised = |by: f64| Aabb2 { min: Vec2::new(311.0, 45.0 + by), ..tall };
+ assert_eq!(place_lines(raised(0.5e-9), 4, 2.5, 4.0, HAlign::Left, true).unwrap().1, None);
+ assert_eq!(place_lines(raised(2e-9), 4, 2.5, 4.0, HAlign::Left, true).unwrap().1, Some(Warning::Height));
+ // One centred line fits while its cap height does and its descenders stay in the 1 mm padding:
+ // a 2.5 mm line's 0.75 mm do, so it fits a 2.5 mm box (not 2.6 mm of line). A 5 mm line's
+ // 1.5 mm reach 0.5 mm past the padding from a baseline on the box's bottom, so it needs 6 mm.
+ let low = |height: f64| rect(0.0, 0.0, 10.0, height);
+ assert_eq!(place_lines(low(2.5), 1, 2.5, 4.0, HAlign::Left, false), Ok((Vec2::new(0.0, 0.0), None)));
+ assert_eq!(place_lines(low(2.5), 1, 2.6, 4.0, HAlign::Left, false).unwrap().1, Some(Warning::Height));
+ assert_eq!(place_lines(low(6.0), 1, 5.0, 8.0, HAlign::Left, false), Ok((Vec2::new(0.0, 0.5), None)));
+ for height in [5.0, 5.9] {
+ assert_eq!(place_lines(low(height), 1, 5.0, 8.0, HAlign::Left, false).unwrap().1, Some(Warning::Height), "{height}");
+ }
+ // The same for the last of several: two 5 mm lines 8 mm apart need 13.5 mm, not 13.4.
+ assert_eq!(place_lines(low(13.5), 2, 5.0, 8.0, HAlign::Left, true), Ok((Vec2::new(0.0, 8.5), None)));
+ assert_eq!(place_lines(low(13.4), 2, 5.0, 8.0, HAlign::Left, true).unwrap().1, Some(Warning::Height));
+ // A flat box holds no line; no lines never overflow; a vast count still answers.
+ assert_eq!(place_lines(rect(0.0, 1.0, 10.0, 1.0), 1, 1.0, 1.6, HAlign::Left, false).unwrap().1, Some(Warning::Height));
+ assert_eq!(place_lines(rect(0.0, 1.0, 10.0, 1.0), 0, 1.0, 1.6, HAlign::Left, false).unwrap().1, None);
+ assert_eq!(place_lines(tall, usize::MAX, 2.5, 4.0, HAlign::Left, true).unwrap().1, Some(Warning::Height));
+}
+
+#[test]
+fn a_hostile_value_box_cap_or_pitch_is_refused() {
+ const BOX: Invalid = Invalid("a value box is not inside out and lies within the paper's coordinates");
+ const SIZES: Invalid = Invalid("a cap height and a line pitch are finite and above 0");
+ for value_box in [
+ Aabb2::EMPTY,
+ rect(10.0, 0.0, 9.0, 5.0),
+ rect(0.0, 5.0, 10.0, 4.999),
+ rect(f64::NAN, 0.0, 10.0, 5.0),
+ rect(0.0, 0.0, f64::INFINITY, 5.0),
+ rect(0.0, f64::NEG_INFINITY, 10.0, 5.0),
+ // Finite and in order, but past the paper's coordinates: centred, they would overflow.
+ rect(1e308, 0.0, 1.1e308, 10.0),
+ rect(0.0, 1e308, 10.0, 1.1e308),
+ rect(0.0, 0.0, 100_000.001, 5.0),
+ rect(-100_000.001, 0.0, 10.0, 5.0),
+ ] {
+ assert_eq!(place_lines(value_box, 1, 2.5, 4.0, HAlign::Left, false), Err(BOX), "{value_box:?}");
+ }
+ for v in [0.0, -0.0, -1.0, f64::NAN, f64::INFINITY] {
+ assert_eq!(place_lines(TITLE_BOX, 1, v, 4.0, HAlign::Left, false), Err(SIZES), "cap {v}");
+ assert_eq!(place_lines(TITLE_BOX, 1, 2.5, v, HAlign::Left, false), Err(SIZES), "pitch {v}");
+ }
+ place_lines(TITLE_BOX, 1, f64::MIN_POSITIVE, f64::MIN_POSITIVE, HAlign::Left, false).unwrap();
+ let paper = rect(-MAX_COORDINATE_MM, -MAX_COORDINATE_MM, MAX_COORDINATE_MM, MAX_COORDINATE_MM);
+ for align in [HAlign::Left, HAlign::Centre, HAlign::Right] {
+ assert!(place_lines(paper, 1, 2.5, 4.0, align, false).unwrap().0.is_finite(), "{align:?}");
+ }
+}
+
+#[test]
+fn a_count_warns_above_its_maximum_in_characters_not_bytes() {
+ let title = Fit { max_chars: Some(25), wide_max_chars: Some(30), wrap: false };
+ let chars = |count, max| Some(Warning::Chars { count, max });
+ let repeat = |c: &str, n: usize| c.repeat(n);
+ assert_eq!(title.warn_chars(&repeat("0", 25)), None);
+ assert_eq!(title.warn_chars(&repeat("0", 26)), chars(26, 25));
+ assert_eq!(title.warn_chars(&repeat("0", 40)), chars(40, 25));
+ // 'é' is two bytes and one character.
+ assert_eq!(title.warn_chars(&repeat("é", 25)), None);
+ assert_eq!(title.warn_chars(&repeat("é", 40)), chars(40, 25));
+ // A text with a wide character is held to the wide count, whatever else it holds.
+ assert_eq!(title.warn_chars(&repeat("字", 30)), None);
+ assert_eq!(title.warn_chars(&repeat("字", 31)), chars(31, 30));
+ assert_eq!(title.warn_chars(&format!("A{}", repeat("字", 29))), None);
+ assert_eq!(title.warn_chars(&format!("{}字", repeat("A", 30))), chars(31, 30));
+ // Line breaks don't count.
+ assert_eq!(title.warn_chars(&format!("{}\n", repeat("0", 25))), None);
+ assert_eq!(title.warn_chars(""), None);
+ // No wide count: the count holds for every text. No count: nothing warns.
+ let plain = Fit { max_chars: Some(25), ..Fit::default() };
+ assert_eq!(plain.warn_chars(&repeat("字", 26)), chars(26, 25));
+ let wide_only = Fit { wide_max_chars: Some(30), ..Fit::default() };
+ assert_eq!(wide_only.warn_chars(&repeat("0", 1000)), None);
+ assert_eq!(wide_only.warn_chars(&repeat("字", 31)), chars(31, 30));
+ assert_eq!(Fit::default().warn_chars(&repeat("字", 1000)), None);
+ let none = Fit { max_chars: Some(0), ..Fit::default() };
+ assert_eq!(none.warn_chars("a"), chars(1, 0));
+ assert_eq!(none.warn_chars("\n"), None);
+}
+
+#[test]
+fn wide_characters_are_those_of_the_wide_scripts_blocks() {
+ for c in ['字', '한', 'カ', 'ひ', 'A', '。', 'ꀀ', '\u{1100}', '\u{115F}', '\u{303E}', '\u{20000}', '\u{3FFFD}', '\u{FFE6}'] {
+ assert!(is_wide(c), "{c:?} U+{:04X}", u32::from(c));
+ }
+ for c in ['A', 'é', 'Ω', 'Я', 'א', '\u{1160}', '\u{303F}', '\u{3040}', '\u{FF61}', '\u{FFE7}', '\u{3FFFE}', '😀', '\n'] {
+ assert!(!is_wide(c), "{c:?} U+{:04X}", u32::from(c));
+ }
+}
+
+#[test]
+fn content_has_at_most_64_parts_and_4096_bytes_of_text() {
+ Content(vec![text("a"); MAX_PARTS]).validate().unwrap();
+ assert_eq!(Content(vec![text(""); MAX_PARTS + 1]).validate(), Err(Invalid("a cell has at most 64 parts")));
+ const LONG: Invalid = Invalid("a cell's text is at most 4096 bytes");
+ Content(vec![text(&"a".repeat(4096))]).validate().unwrap();
+ assert_eq!(Content(vec![text(&"a".repeat(4097))]).validate(), Err(LONG));
+ // Bytes, not characters: 2048 'é' are 4096 bytes.
+ Content(vec![text(&"é".repeat(2048))]).validate().unwrap();
+ assert_eq!(Content(vec![text(&"é".repeat(2048)), text("a")]).validate(), Err(LONG));
+ // Keys and units count too.
+ let unit =
+ |unit: &str| Part::Field { source: Source::Component, key: "k".repeat(2047), format: Format { unit: Some(unit.into()), decimals: None } };
+ Content(vec![text(&"a".repeat(2048)), unit("g")]).validate().unwrap();
+ assert_eq!(Content(vec![text(&"a".repeat(2048)), unit("kg")]).validate(), Err(LONG));
+ assert_eq!(Content(vec![text(&"a".repeat(2048)), field(Source::Drawing, &"k".repeat(2049))]).validate(), Err(LONG));
+ // Counted first: 65 parts of bad text report the count.
+ assert_eq!(Content(vec![text("\t"); MAX_PARTS + 1]).validate(), Err(Invalid("a cell has at most 64 parts")));
+ Content::default().validate().unwrap();
+}
+
+#[test]
+fn content_has_no_control_character_but_a_line_break() {
+ const CONTROL: Invalid = Invalid("a cell's text has no control character but a line break");
+ Content(vec![text("Anodised\nblack"), text("\n")]).validate().unwrap();
+ for c in ['\t', '\r', '\0', '\u{1b}', '\u{7f}', '\u{85}', '\u{9f}'] {
+ let s = format!("a{c}b");
+ assert_eq!(Content(vec![text(&s)]).validate(), Err(CONTROL), "{c:?}");
+ assert_eq!(Content(vec![field(Source::Sheet, &s)]).validate(), Err(CONTROL), "{c:?}");
+ let format = Format { unit: Some(s), decimals: Some(1) };
+ assert_eq!(Content(vec![Part::Field { source: Source::Component, key: "mass".into(), format }]).validate(), Err(CONTROL), "{c:?}");
+ }
+}
+
+#[test]
+fn parts_read_and_write_as_externally_tagged_json() {
+ let content = Content(vec![
+ text("Sheet "),
+ field(Source::Sheet, "number"),
+ Part::Field { source: Source::Component, key: "mass".into(), format: Format { unit: Some("g".into()), decimals: Some(1) } },
+ ]);
+ let value = serde_json::to_value(&content).unwrap();
+ assert_eq!(
+ value,
+ json!([
+ {"text": "Sheet "},
+ {"field": {"source": "sheet", "key": "number", "format": {"unit": null, "decimals": null}}},
+ {"field": {"source": "component", "key": "mass", "format": {"unit": "g", "decimals": 1}}},
+ ])
+ );
+ assert_eq!(serde_json::from_value::<Content>(value).unwrap(), content);
+ // Without a format, the caller's settings.
+ let read = |v: serde_json::Value| serde_json::from_value::<Content>(json!([v]));
+ assert_eq!(read(json!({"field": {"source": "revision", "key": "date"}})).unwrap(), Content(vec![field(Source::Revision, "date")]));
+ for (name, source) in [
+ ("component", Source::Component),
+ ("drawing", Source::Drawing),
+ ("sheet", Source::Sheet),
+ ("revision", Source::Revision),
+ ("prompt", Source::Prompt),
+ ] {
+ assert_eq!(serde_json::to_value(source).unwrap(), json!(name));
+ }
+ for bad in [
+ json!({"field": {"source": "customer", "key": "name"}}),
+ json!({"field": {"source": "Component", "key": "name"}}),
+ json!({"field": {"source": "sheet", "key": "number", "scale": 1}}),
+ json!({"field": {"source": "sheet", "key": "number", "format": {"date": "ymd"}}}),
+ json!({"field": {"source": "component", "key": "mass", "format": {"decimals": 256}}}),
+ json!({"field": {"source": "component", "key": "mass", "format": {"decimals": -1}}}),
+ json!({"field": {"source": "component", "key": "mass", "format": {"decimals": 1.5}}}),
+ json!({"field": {"source": "sheet"}}),
+ json!({"field": {"source": "sheet", "key": 1}}),
+ json!({"expr": "a + 1"}),
+ json!({"text": "a", "field": {"source": "sheet", "key": "number"}}),
+ json!({"kind": "text", "text": "a"}),
+ json!("Sheet"),
+ ] {
+ assert!(read(bad.clone()).is_err(), "{bad}");
+ }
+}
+
+#[test]
+fn a_label_is_one_line_of_at_most_4096_bytes() {
+ const LABEL: Invalid = Invalid("a label is one line of at most 4096 bytes");
+ for ok in ["Created by", "", "Masse (kg)", &"é".repeat(2048)] {
+ check_label(ok).unwrap();
+ }
+ for bad in ["Title\nblock", "\t", "a\u{85}", &"a".repeat(4097), &"é".repeat(2049)] {
+ assert_eq!(check_label(bad), Err(LABEL), "{bad:?}");
+ }
+}
+
+#[test]
+fn alignments_projections_and_fits_have_snake_case_names() {
+ for (align, name) in [(HAlign::Left, "left"), (HAlign::Centre, "centre"), (HAlign::Right, "right")] {
+ assert_eq!(serde_json::to_value(align).unwrap(), json!(name));
+ assert_eq!(serde_json::from_value::<HAlign>(json!(name)).unwrap(), align);
+ }
+ assert_eq!(HAlign::default(), HAlign::Left);
+ for (projection, name) in [(Projection::First, "first"), (Projection::Third, "third")] {
+ assert_eq!(serde_json::to_value(projection).unwrap(), json!(name));
+ assert_eq!(serde_json::from_value::<Projection>(json!(name)).unwrap(), projection);
+ }
+ for bad in ["center", "Left", "middle", ""] {
+ assert!(serde_json::from_value::<HAlign>(json!(bad)).is_err(), "{bad}");
+ }
+ for bad in ["First", "first_angle", "second", ""] {
+ assert!(serde_json::from_value::<Projection>(json!(bad)).is_err(), "{bad}");
+ }
+ let fit = Fit { max_chars: Some(25), wide_max_chars: Some(30), wrap: true };
+ let value = serde_json::to_value(fit).unwrap();
+ assert_eq!(value, json!({"max_chars": 25, "wide_max_chars": 30, "wrap": true}));
+ assert_eq!(serde_json::from_value::<Fit>(value).unwrap(), fit);
+ assert_eq!(serde_json::from_value::<Fit>(json!({})).unwrap(), Fit::default());
+ assert!(serde_json::from_value::<Fit>(json!({"padding_mm": 1.0})).is_err());
+ assert!(serde_json::from_value::<Fit>(json!({"max_chars": -1})).is_err());
+}
+
+/// A whole number below `n` from `rng`.
+fn pick(rng: &mut Lcg, n: usize) -> usize {
+ ((rng.unit() * n as f64) as usize).min(n - 1)
+}
+
+/// Random content, texts and boxes, hostile ones among them: validation agrees with the rule worked
+/// out independently, the count agrees with one by hand, and nothing panics.
+#[test]
+fn fuzzed_content_texts_and_boxes_never_panic_and_follow_the_rules() {
+ const CHARS: [char; 14] = ['a', 'Z', '0', ' ', '\n', '\t', '\r', '\u{7f}', '\u{85}', 'é', '字', '한', '😀', '\0'];
+ const NUMBERS: [f64; 13] = [0.0, -1.0, 1e-300, 2.5, 5.0, 14.5, 1e5, 1.1e5, -1e308, 1e308, f64::NAN, f64::INFINITY, f64::NEG_INFINITY];
+ let string = |rng: &mut Lcg, len: usize| -> String { (0..len).map(|_| CHARS[pick(rng, CHARS.len())]).collect() };
+ let number = |rng: &mut Lcg| if pick(rng, 4) == 0 { NUMBERS[pick(rng, NUMBERS.len())] } else { rng.unit() * 200.0 - 50.0 };
+ let mut rng = Lcg(0x5eed);
+ let mut accepted = 0;
+ let mut combinations = std::collections::BTreeSet::new();
+ for round in 0..3000 {
+ let lengths = [0, 1, 7, 60, 1100, 4097];
+ let mut parts = Vec::new();
+ for i in 0..[0, 1, 3, 64, 65][round % 5] {
+ let len = lengths[(round + i) % lengths.len()];
+ parts.push(match i % 3 {
+ 0 => Part::Text(string(&mut rng, len)),
+ 1 => Part::Field { source: Source::Drawing, key: string(&mut rng, len % 40), format: Format::default() },
+ _ => {
+ let format = Format { unit: Some(string(&mut rng, len % 5)), decimals: Some(3) };
+ Part::Field { source: Source::Component, key: "mass".into(), format }
+ }
+ });
+ }
+ let content = Content(parts);
+ let strings: Vec<&str> = content
+ .0
+ .iter()
+ .flat_map(|p| match p {
+ Part::Text(t) => vec![t.as_str()],
+ Part::Field { key, format, .. } => [Some(key.as_str()), format.unit.as_deref()].into_iter().flatten().collect(),
+ })
+ .collect();
+ let bytes: usize = strings.iter().map(|s| s.len()).sum();
+ let clean = strings.iter().all(|s| s.chars().all(|c| c == '\n' || !c.is_control()));
+ let valid = content.0.len() <= MAX_PARTS && bytes <= MAX_TEXT_BYTES && clean;
+ assert_eq!(content.validate().is_ok(), valid, "round {round}: {} parts, {bytes} bytes, clean {clean}", content.0.len());
+ accepted += usize::from(valid);
+ let back: Content = serde_json::from_value(serde_json::to_value(&content).unwrap()).unwrap();
+ assert_eq!(back, content);
+ let fit = Fit { max_chars: Some(30), wide_max_chars: Some(20), wrap: false };
+ for s in &strings {
+ let count = s.chars().filter(|&c| c != '\n').count();
+ let max = if s.chars().any(is_wide) { 20 } else { 30 };
+ assert_eq!(fit.warn_chars(s), (count > max as usize).then_some(Warning::Chars { count, max }), "{s:?}");
+ }
+ let (x0, y0, x1, y1, cap, pitch) =
+ (number(&mut rng), number(&mut rng), number(&mut rng), number(&mut rng), number(&mut rng), number(&mut rng));
+ // Each of the lines, the alignment and the wrapping picked on its own, so every combination comes up.
+ let lines = [0, 1, 2, 5, 1000, usize::MAX][pick(&mut rng, 6)];
+ let (align, wrap) = ([HAlign::Left, HAlign::Centre, HAlign::Right][pick(&mut rng, 3)], pick(&mut rng, 2) == 0);
+ combinations.insert((lines, align as u8, wrap));
+ let value_box = rect(x0, y0, x1, y1);
+ let on_paper = [x0, y0, x1, y1].iter().all(|v| v.abs() <= MAX_COORDINATE_MM);
+ let sane = on_paper && [cap, pitch].iter().all(|v| v.is_finite() && *v > 0.0) && x0 <= x1 && y0 <= y1;
+ let placed = place_lines(value_box, lines, cap, pitch, align, wrap);
+ assert_eq!(placed.is_ok(), sane, "{value_box:?} {cap} {pitch}");
+ if let Ok((at, warning)) = placed {
+ assert!(at.is_finite() && at.x >= x0 && at.x <= x1 && at.y <= y1, "{at:?} in {value_box:?}");
+ if lines == 1 && warning.is_none() {
+ // Its baseline in the box, and its descenders above the line's inner edge, the padding below it.
+ assert!(at.y >= y0 - EPS && at.y - cap * DESCENDER_OF_CAP >= y0 - PADDING_MM - EPS, "{at:?} {cap} in {value_box:?}");
+ }
+ }
+ }
+ assert!(accepted > 500, "{accepted}");
+ assert_eq!(combinations.len(), 6 * 3 * 2, "every lines, alignment and wrapping together");
+}
diff --git a/crates/geom/src/drawing_sheet.rs b/crates/geom/src/drawing_sheet.rs
new file mode 100644
index 0000000000..86ec18ba28
--- /dev/null
+++ b/crates/geom/src/drawing_sheet.rs
@@ -0,0 +1,521 @@
+//! Drawing sheets: paper sizes, orientation and the drawing border, as data in sheet millimetres.
+//!
+//! A [`Sheet`] is a paper size and an orientation; [`Sheet::size_mm`] gives its size as it lies, the
+//! sheet border running round it. A [`DrawingBorderProfile`] is the rule for the drawing border
+//! inside the sheet border: the margins between the two, the drawing border's line width, the grid
+//! of reference fields with their labels, and the centring and trimming marks.
+//! [`DrawingBorderProfile::validate`] checks a profile on its own, as when one is read, and
+//! [`DrawingBorderProfile::layout`] works it out for one sheet, so a new size regrows it. Nothing
+//! here is frozen geometry, saved in a design or drawn: a writer draws the [`SheetLayout`] later.
+//!
+//! Sheet coordinates are millimetres from the sheet's lower-left corner, x to the right and y up.
+//! The drawing border's line is centred on [`SheetLayout::drawing_border`].
+//!
+//! [`DrawingBorderProfile::iso`] is the built-in profile, after ISO 5457: 10 mm margins all round,
+//! a 0.7 mm drawing border, and 50 mm fields counted out from the sheet's centre lines, the corner
+//! fields taking what is left. Rows are lettered from the top without I and O and columns numbered
+//! from the left, on the sides [`LabelSides::Iso`] gives: the top and right of an A4 sheet, every
+//! side of the others. The labels sit between the drawing border and the grid reference border,
+//! 5 mm outside it. A centring mark runs across the whole margin, from the trimmed sheet's edge to
+//! the drawing border, at each end of the sheet's centre lines, never into the drawing area.
+//!
+//! The rest of ISO 5457's border is a choice in the profile: the 20 mm filing margin on the left,
+//! for drawings that get bound; centring marks that start at the grid reference border and reach
+//! inside the drawing border (10 mm in the standard's figure); and a trimming mark at each corner, outside the grid reference border, of
+//! two overlapping 10 x 5 mm rectangles. The built-in profile leaves the trimming marks out, as
+//! they take a lot of ink.
+//!
+//! Sizes: ISO 216 A0 to A5, Letter and Legal, ANSI A to F (ASME Y14.1), the architectural A to E
+//! and E1, and custom sizes, finite, above 0 and at most [`MAX_SIDE_MM`] a side. Title blocks sit on
+//! the drawing border ([`crate::title_block`]). The elongated ISO sizes and the extra centring marks a
+//! sheet larger than A0 needs (one in the middle of each section to be filmed) are not here yet.
+
+use serde::{Deserialize, Serialize};
+
+use crate::paper::MAX_LINE_MM;
+/// The longest side a custom sheet may have, in millimetres: the paper scene's limit.
+pub use crate::paper::MAX_SIDE_MM;
+use crate::{Aabb2, Vec2};
+
+/// The most fields an equal division may cut each way.
+pub const MAX_EQUAL_FIELDS: u32 = 200;
+/// ISO 5457's filing margin: the left margin of a drawing that gets bound.
+pub const FILING_MARGIN_MM: f64 = 20.0;
+const MIN_FIELD_MM: f64 = 1.0;
+const MAX_FIELD_MM: f64 = 1000.0;
+/// The smallest drawing space the margins may leave, each way.
+const MIN_DRAWING_SPACE_MM: f64 = 1.0;
+/// A corner field shorter than this joins its neighbour, so rounding never leaves a sliver.
+const SLIVER_MM: f64 = 1e-9;
+const INCH: f64 = 25.4;
+
+/// A standard paper size.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum PaperSize {
+ A0,
+ A1,
+ A2,
+ A3,
+ A4,
+ A5,
+ Letter,
+ Legal,
+ AnsiA,
+ AnsiB,
+ AnsiC,
+ AnsiD,
+ AnsiE,
+ AnsiF,
+ ArchA,
+ ArchB,
+ ArchC,
+ ArchD,
+ ArchE,
+ ArchE1,
+}
+
+impl PaperSize {
+ pub const ALL: [PaperSize; 20] = {
+ use PaperSize::*;
+ [A0, A1, A2, A3, A4, A5, Letter, Legal, AnsiA, AnsiB, AnsiC, AnsiD, AnsiE, AnsiF, ArchA, ArchB, ArchC, ArchD, ArchE, ArchE1]
+ };
+
+ /// The short and the long side, in millimetres (the US sizes from their inches).
+ pub fn sides_mm(self) -> (f64, f64) {
+ use PaperSize::*;
+ let inches = |short: f64, long: f64| (short * INCH, long * INCH);
+ match self {
+ A0 => (841.0, 1189.0),
+ A1 => (594.0, 841.0),
+ A2 => (420.0, 594.0),
+ A3 => (297.0, 420.0),
+ A4 => (210.0, 297.0),
+ A5 => (148.0, 210.0),
+ Letter | AnsiA => inches(8.5, 11.0),
+ Legal => inches(8.5, 14.0),
+ AnsiB => inches(11.0, 17.0),
+ AnsiC => inches(17.0, 22.0),
+ AnsiD => inches(22.0, 34.0),
+ AnsiE => inches(34.0, 44.0),
+ AnsiF => inches(28.0, 40.0),
+ ArchA => inches(9.0, 12.0),
+ ArchB => inches(12.0, 18.0),
+ ArchC => inches(18.0, 24.0),
+ ArchD => inches(24.0, 36.0),
+ ArchE => inches(36.0, 48.0),
+ ArchE1 => inches(30.0, 42.0),
+ }
+ }
+}
+
+/// A sheet's size: a standard one or any other.
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case", deny_unknown_fields)]
+pub enum SheetSize {
+ Standard(PaperSize),
+ /// The two sides in either order; the orientation decides which lies across.
+ Custom {
+ sides_mm: [f64; 2],
+ },
+}
+
+/// Which way the sheet lies. Landscape puts the long side across.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum Orientation {
+ #[default]
+ Landscape,
+ Portrait,
+}
+
+/// One sheet: its size and the way it lies (landscape when not given).
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct Sheet {
+ pub size: SheetSize,
+ #[serde(default)]
+ pub orientation: Orientation,
+}
+
+/// The distances from the sheet border to the drawing border, in millimetres.
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct Margins {
+ pub left_mm: f64,
+ pub right_mm: f64,
+ pub top_mm: f64,
+ pub bottom_mm: f64,
+}
+
+impl Margins {
+ /// Left, right, top and bottom.
+ fn sides(self) -> [f64; 4] {
+ [self.left_mm, self.right_mm, self.top_mm, self.bottom_mm]
+ }
+}
+
+/// How the drawing border is cut into reference fields. Externally tagged (`"none"`,
+/// `{"from_centre": {...}}`), as serde ignores extra fields on an internally tagged unit variant.
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case", deny_unknown_fields)]
+pub enum GridRule {
+ /// No reference fields.
+ None,
+ /// Fields of `field_mm` counted out from the sheet's centre lines, the corner fields taking
+ /// what is left (ISO 5457, with 50 mm). Each way the larger half sets the count `n` (its
+ /// length over `field_mm`, rounded, at least 1), and each half has `n` fields, or fewer where
+ /// it is shorter.
+ FromCentre { field_mm: f64 },
+ /// The drawing border cut into equal fields.
+ Equal { columns: u32, rows: u32 },
+}
+
+/// Sides of the drawing border.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct Sides {
+ pub top: bool,
+ pub bottom: bool,
+ pub left: bool,
+ pub right: bool,
+}
+
+impl Sides {
+ pub const ALL: Sides = Sides { top: true, bottom: true, left: true, right: true };
+}
+
+/// Which sides of the drawing border carry the field labels: a rule for any sheet, so a profile
+/// made for one size labels another correctly.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case", deny_unknown_fields)]
+pub enum LabelSides {
+ /// ISO 5457's: the top and right of an A4 sheet (either way), every side of the others.
+ Iso,
+ /// The same sides on every sheet.
+ Fixed(Sides),
+}
+
+impl LabelSides {
+ /// The sides labelled on `sheet`.
+ pub fn on(self, sheet: &Sheet) -> Sides {
+ match self {
+ LabelSides::Iso if matches!(sheet.size, SheetSize::Standard(PaperSize::A4)) => {
+ Sides { top: true, bottom: false, left: false, right: true }
+ }
+ LabelSides::Iso => Sides::ALL,
+ LabelSides::Fixed(sides) => sides,
+ }
+ }
+}
+
+/// The rule for a drawing border and the marks around it: worked out for each sheet by
+/// [`DrawingBorderProfile::layout`].
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct DrawingBorderProfile {
+ pub margins: Margins,
+ /// ISO 5457's filing margin: when on, the left margin is [`FILING_MARGIN_MM`] in place of
+ /// `margins.left_mm`, which is kept for when it's off again. Off when not given.
+ #[serde(default)]
+ pub filing_margin: bool,
+ /// The drawing border's line width; the centring marks are drawn in it too.
+ pub drawing_border_line_mm: f64,
+ pub grid: GridRule,
+ /// Row letters skip I and O (they read as 1 and 0).
+ pub skip_i_and_o: bool,
+ pub label_sides: LabelSides,
+ /// How far outside the drawing border the grid reference border runs; the labels sit between
+ /// the two.
+ pub grid_border_mm: f64,
+ /// How far each centring mark reaches inside the drawing border, 0 to stop it on the drawing
+ /// border, at most [`MAX_SIDE_MM`] (`None`: no centring marks).
+ pub centring_mark_mm: Option<f64>,
+ /// Where each centring mark starts outside the drawing border. The trimmed sheet's edge when not
+ /// given.
+ #[serde(default)]
+ pub centring_mark_start: CentringMarkStart,
+ /// The trimming mark's rectangles: their length along the sheet border, at most
+ /// [`MAX_SIDE_MM`], and their width into the sheet, which must leave them outside the grid
+ /// reference border (`None`: no trimming marks).
+ pub trimming_mark_mm: Option<[f64; 2]>,
+}
+
+/// Where a centring mark starts, outside the drawing border.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum CentringMarkStart {
+ /// The trimmed sheet's edge, so the mark runs across the whole margin (the built-in sheet's).
+ #[default]
+ SheetEdge,
+ /// The grid reference border, as ISO 5457's figure 5 draws it.
+ GridBorder,
+}
+
+/// One reference field along its axis: `from_mm < to_mm` in sheet coordinates.
+#[derive(Clone, Debug, PartialEq)]
+pub struct Field {
+ pub from_mm: f64,
+ pub to_mm: f64,
+ pub label: String,
+}
+
+/// A sheet's drawing border and the marks around it, worked out: what a writer draws.
+#[derive(Clone, Debug, PartialEq)]
+pub struct SheetLayout {
+ pub sheet_border: Aabb2,
+ pub drawing_border: Aabb2,
+ pub drawing_border_line_mm: f64,
+ /// Left to right, numbered from 1.
+ pub columns: Vec<Field>,
+ /// Top to bottom, lettered from A.
+ pub rows: Vec<Field>,
+ /// The sides labelled on this sheet.
+ pub label_sides: Sides,
+ pub grid_border: Aabb2,
+ /// Bottom, top, left and right: each from the grid reference border to the drawing border, or
+ /// as far inside it as the profile asks.
+ pub centring_marks: Vec<[Vec2; 2]>,
+ /// Filled rectangles, two at each corner of the sheet.
+ pub trimming_marks: Vec<Aabb2>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
+#[error("drawing sheet: {0}")]
+pub struct Invalid(pub &'static str);
+
+type Result<T> = std::result::Result<T, Invalid>;
+
+fn require(condition: bool, message: &'static str) -> Result<()> {
+ if condition { Ok(()) } else { Err(Invalid(message)) }
+}
+
+impl Sheet {
+ pub fn standard(size: PaperSize, orientation: Orientation) -> Sheet {
+ Sheet { size: SheetSize::Standard(size), orientation }
+ }
+
+ /// The sheet's width and height as it lies.
+ pub fn size_mm(&self) -> Result<Vec2> {
+ let (short, long) = match self.size {
+ SheetSize::Standard(size) => size.sides_mm(),
+ SheetSize::Custom { sides_mm: [a, b] } => {
+ for side in [a, b] {
+ require(side.is_finite() && side > 0.0 && side <= MAX_SIDE_MM, "a custom side is finite, above 0 and at most 5000 mm")?;
+ }
+ (a.min(b), a.max(b))
+ }
+ };
+ Ok(match self.orientation {
+ Orientation::Landscape => Vec2::new(long, short),
+ Orientation::Portrait => Vec2::new(short, long),
+ })
+ }
+}
+
+impl DrawingBorderProfile {
+ /// The built-in drawing border, after ISO 5457, for a sheet of any size (the module's notes
+ /// say how it follows the standard).
+ pub fn iso() -> DrawingBorderProfile {
+ DrawingBorderProfile {
+ margins: Margins { left_mm: 10.0, right_mm: 10.0, top_mm: 10.0, bottom_mm: 10.0 },
+ filing_margin: false,
+ drawing_border_line_mm: 0.7,
+ grid: GridRule::FromCentre { field_mm: 50.0 },
+ skip_i_and_o: true,
+ label_sides: LabelSides::Iso,
+ grid_border_mm: 5.0,
+ centring_mark_mm: Some(0.0),
+ centring_mark_start: CentringMarkStart::SheetEdge,
+ trimming_mark_mm: None,
+ }
+ }
+
+ /// The margins as laid out: `margins`, with the filing margin on the left when it's on.
+ fn laid_out_margins(&self) -> Margins {
+ let left_mm = if self.filing_margin { FILING_MARGIN_MM } else { self.margins.left_mm };
+ Margins { left_mm, ..self.margins }
+ }
+
+ /// Checks what doesn't depend on the sheet: call it when a profile is read. [`Self::layout`]
+ /// calls it too.
+ pub fn validate(&self) -> Result<()> {
+ // Every margin as given, the left one too while the filing margin stands in for it, so
+ // turning the filing margin off never brings back a bad value.
+ for margin in self.margins.sides() {
+ require(margin.is_finite() && (0.0..=MAX_SIDE_MM).contains(&margin), "a margin is finite and 0 to 5000 mm")?;
+ }
+ let line = self.drawing_border_line_mm;
+ require(line.is_finite() && line > 0.0 && line <= MAX_LINE_MM, "the drawing border's line is above 0 and at most 10 mm wide")?;
+ match self.grid {
+ GridRule::None => {}
+ GridRule::FromCentre { field_mm } => {
+ require(field_mm.is_finite() && (MIN_FIELD_MM..=MAX_FIELD_MM).contains(&field_mm), "a field is 1 to 1000 mm long")?
+ }
+ GridRule::Equal { columns, rows } => {
+ let counts = 1..=MAX_EQUAL_FIELDS;
+ require(counts.contains(&columns) && counts.contains(&rows), "an equal division has 1 to 200 fields each way")?
+ }
+ }
+ // The grid reference border lies in the margins, and the trimming marks between it and the
+ // sheet border (ISO 5457 4.5), so the narrowest margin laid out bounds both.
+ let narrowest = self.laid_out_margins().sides().into_iter().fold(f64::INFINITY, f64::min);
+ let g = self.grid_border_mm;
+ require(g.is_finite() && g >= 0.0 && g <= narrowest, "the grid reference border lies between the sheet border and the drawing border")?;
+ if let Some(reach) = self.centring_mark_mm {
+ let fits = reach.is_finite() && (0.0..=MAX_SIDE_MM).contains(&reach);
+ require(fits, "a centring mark ends on the drawing border or at most 5000 mm inside it")?;
+ // Else it would start and end on the drawing border.
+ let outside = match self.centring_mark_start {
+ CentringMarkStart::SheetEdge => narrowest,
+ CentringMarkStart::GridBorder => g,
+ };
+ require(outside > 0.0 || reach > 0.0, "a centring mark needs room outside the drawing border to start from, or a reach inside it")?;
+ }
+ if let Some([length, width]) = self.trimming_mark_mm {
+ let fits = length.is_finite() && length <= MAX_SIDE_MM && width > 0.0 && width <= length;
+ require(fits, "a trimming mark is above 0, at most 5000 mm long and no wider than it is long")?;
+ require(width <= narrowest - g, "a trimming mark lies between the sheet border and the grid reference border")?;
+ }
+ Ok(())
+ }
+
+ /// The drawing border and the marks around it on `sheet`.
+ pub fn layout(&self, sheet: &Sheet) -> Result<SheetLayout> {
+ self.validate()?;
+ let size = sheet.size_mm()?;
+ let m = self.laid_out_margins();
+ let drawing_border = Aabb2 { min: Vec2::new(m.left_mm, m.bottom_mm), max: Vec2::new(size.x - m.right_mm, size.y - m.top_mm) };
+ let space = drawing_border.size();
+ require(space.x >= MIN_DRAWING_SPACE_MM && space.y >= MIN_DRAWING_SPACE_MM, "the margins leave no drawing space")?;
+ let (across, down) = match self.grid {
+ GridRule::None => (vec![], vec![]),
+ GridRule::FromCentre { field_mm } => (
+ from_centre(drawing_border.min.x, drawing_border.max.x, size.x / 2.0, field_mm)?,
+ from_centre(drawing_border.min.y, drawing_border.max.y, size.y / 2.0, field_mm)?,
+ ),
+ GridRule::Equal { columns, rows } => {
+ (equal(drawing_border.min.x, drawing_border.max.x, columns), equal(drawing_border.min.y, drawing_border.max.y, rows))
+ }
+ };
+ let columns = fields(&across, |i| (i + 1).to_string());
+ // Rows run top to bottom: the edges are in rising y, so the top row comes last.
+ let mut rows = fields(&down, |_| String::new());
+ rows.reverse();
+ for (i, row) in rows.iter_mut().enumerate() {
+ row.label = letters(i, self.skip_i_and_o);
+ }
+ let sheet_border = Aabb2 { min: Vec2::ZERO, max: size };
+ let grid_border = drawing_border.inflated(self.grid_border_mm);
+ let start = match self.centring_mark_start {
+ CentringMarkStart::SheetEdge => sheet_border,
+ CentringMarkStart::GridBorder => grid_border,
+ };
+ let centring_marks = match self.centring_mark_mm {
+ Some(reach) => centring_marks(start, drawing_border, size, reach)?,
+ None => Vec::new(),
+ };
+ let trimming_marks = match self.trimming_mark_mm {
+ Some(mark) => trimming_marks(size, mark)?,
+ None => Vec::new(),
+ };
+ Ok(SheetLayout {
+ sheet_border,
+ drawing_border,
+ drawing_border_line_mm: self.drawing_border_line_mm,
+ columns,
+ rows,
+ label_sides: self.label_sides.on(sheet),
+ grid_border,
+ centring_marks,
+ trimming_marks,
+ })
+ }
+}
+
+/// The four centring marks: on the sheet's centre lines, from the edges of `start` to `reach`
+/// inside the drawing border, which must not take them past the centre.
+fn centring_marks(start: Aabb2, drawing_border: Aabb2, size: Vec2, reach: f64) -> Result<Vec<[Vec2; 2]>> {
+ let (cx, cy) = (size.x / 2.0, size.y / 2.0);
+ let (lo, hi) = (drawing_border.min, drawing_border.max);
+ let room = (cx - lo.x).min(hi.x - cx).min(cy - lo.y).min(hi.y - cy);
+ require(reach <= room, "a centring mark stops at the sheet's centre lines")?;
+ Ok(vec![
+ [Vec2::new(cx, start.min.y), Vec2::new(cx, lo.y + reach)],
+ [Vec2::new(cx, start.max.y), Vec2::new(cx, hi.y - reach)],
+ [Vec2::new(start.min.x, cy), Vec2::new(lo.x + reach, cy)],
+ [Vec2::new(start.max.x, cy), Vec2::new(hi.x - reach, cy)],
+ ])
+}
+
+/// The trimming marks: at each corner of the sheet, a rectangle `length` along each edge and
+/// `width` into the sheet, the two overlapping in the corner.
+fn trimming_marks(size: Vec2, [length, width]: [f64; 2]) -> Result<Vec<Aabb2>> {
+ // Any longer and the two marks on one edge would meet.
+ require(length <= size.x.min(size.y) / 2.0, "a trimming mark is at most half the sheet's shorter side long")?;
+ // The span `extent` long from one end of `0..side`, the far end when `far`.
+ let span = |far: bool, side: f64, extent: f64| if far { (side - extent, side) } else { (0.0, extent) };
+ let mut marks = Vec::with_capacity(8);
+ for (right, top) in [(false, false), (true, false), (false, true), (true, true)] {
+ for (across, up) in [(length, width), (width, length)] {
+ let ((x0, x1), (y0, y1)) = (span(right, size.x, across), span(top, size.y, up));
+ marks.push(Aabb2 { min: Vec2::new(x0, y0), max: Vec2::new(x1, y1) });
+ }
+ }
+ Ok(marks)
+}
+
+/// The field edges from `lo` to `hi`, in rising order, for fields of `field` out from `centre`.
+fn from_centre(lo: f64, hi: f64, centre: f64, field: f64) -> Result<Vec<f64>> {
+ let (below, above) = (centre - lo, hi - centre);
+ require(below > SLIVER_MM && above > SLIVER_MM, "the sheet's centre lines cross the drawing border")?;
+ // At most MAX_SIDE_MM / MIN_FIELD_MM per half: a bounded count.
+ let n = (below.max(above) / field).round().max(1.0);
+ let count = |half: f64| n.min(((half - SLIVER_MM) / field).ceil()) as usize;
+ let (k_below, k_above) = (count(below), count(above));
+ let mut edges = Vec::with_capacity(k_below + k_above + 1);
+ edges.push(lo);
+ edges.extend((1..k_below).rev().map(|j| centre - j as f64 * field));
+ edges.push(centre);
+ edges.extend((1..k_above).map(|j| centre + j as f64 * field));
+ edges.push(hi);
+ Ok(edges)
+}
+
+/// The edges of `n` equal fields from `lo` to `hi`, ending exactly at `hi`.
+fn equal(lo: f64, hi: f64, n: u32) -> Vec<f64> {
+ let step = (hi - lo) / f64::from(n);
+ (0..n).map(|i| lo + f64::from(i) * step).chain(std::iter::once(hi)).collect()
+}
+
+fn fields(edges: &[f64], label: impl Fn(usize) -> String) -> Vec<Field> {
+ edges
+ .windows(2)
+ .enumerate()
+ .filter_map(|(i, w)| match *w {
+ [from_mm, to_mm] => Some(Field { from_mm, to_mm, label: label(i) }),
+ _ => None,
+ })
+ .collect()
+}
+
+/// The row label for row `i` (0 is A): A to Z, then AA, AB and on (without I and O if asked).
+pub fn letters(i: usize, skip_i_and_o: bool) -> String {
+ const ALL: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+ const NO_I_O: &[u8] = b"ABCDEFGHJKLMNPQRSTUVWXYZ";
+ let alphabet = if skip_i_and_o { NO_I_O } else { ALL };
+ let base = alphabet.len();
+ let mut out = Vec::new();
+ // Bijective numbering: after the last letter comes AA, not BA.
+ let mut n = i.saturating_add(1);
+ while n > 0 {
+ n -= 1;
+ out.extend(alphabet.get(n % base).map(|&b| char::from(b)));
+ n /= base;
+ }
+ out.iter().rev().collect()
+}
+
+#[cfg(test)]
+#[path = "drawing_sheet_tests.rs"]
+mod tests;
diff --git a/crates/geom/src/drawing_sheet_tests.rs b/crates/geom/src/drawing_sheet_tests.rs
new file mode 100644
index 0000000000..6b6ee2612c
--- /dev/null
+++ b/crates/geom/src/drawing_sheet_tests.rs
@@ -0,0 +1,611 @@
+use super::*;
+
+const EPS: f64 = 1e-9;
+
+fn iso_layout(size: PaperSize, orientation: Orientation) -> SheetLayout {
+ DrawingBorderProfile::iso().layout(&Sheet::standard(size, orientation)).unwrap()
+}
+
+fn with_filing_margin() -> DrawingBorderProfile {
+ DrawingBorderProfile { filing_margin: true, ..DrawingBorderProfile::iso() }
+}
+
+/// ISO 5457's border with every choice on: the filing margin, centring marks from the grid
+/// reference border to 10 mm inside the drawing border, and trimming marks.
+fn full_iso_5457() -> DrawingBorderProfile {
+ DrawingBorderProfile {
+ centring_mark_mm: Some(10.0),
+ centring_mark_start: CentringMarkStart::GridBorder,
+ trimming_mark_mm: Some([10.0, 5.0]),
+ ..with_filing_margin()
+ }
+}
+
+fn lengths(fields: &[Field]) -> Vec<f64> {
+ fields.iter().map(|f| f.to_mm - f.from_mm).collect()
+}
+
+fn close(a: &[f64], b: &[f64]) -> bool {
+ a.len() == b.len() && a.iter().zip(b).all(|(x, y)| (x - y).abs() < EPS)
+}
+
+#[test]
+fn every_size_is_its_published_millimetres() {
+ use PaperSize::*;
+ let expected = [
+ (A0, 841.0, 1189.0),
+ (A1, 594.0, 841.0),
+ (A2, 420.0, 594.0),
+ (A3, 297.0, 420.0),
+ (A4, 210.0, 297.0),
+ (A5, 148.0, 210.0),
+ (Letter, 215.9, 279.4),
+ (Legal, 215.9, 355.6),
+ (AnsiA, 215.9, 279.4),
+ (AnsiB, 279.4, 431.8),
+ (AnsiC, 431.8, 558.8),
+ (AnsiD, 558.8, 863.6),
+ (AnsiE, 863.6, 1117.6),
+ (AnsiF, 711.2, 1016.0),
+ (ArchA, 228.6, 304.8),
+ (ArchB, 304.8, 457.2),
+ (ArchC, 457.2, 609.6),
+ (ArchD, 609.6, 914.4),
+ (ArchE, 914.4, 1219.2),
+ (ArchE1, 762.0, 1066.8),
+ ];
+ assert_eq!(expected.len(), PaperSize::ALL.len());
+ for (size, short, long) in expected {
+ let (s, l) = size.sides_mm();
+ assert!((s - short).abs() < EPS && (l - long).abs() < EPS, "{size:?}: {s} x {l}");
+ }
+}
+
+#[test]
+fn landscape_is_the_default_and_either_orientation_turns_every_size() {
+ let sheet: Sheet = serde_json::from_value(serde_json::json!({"size": {"standard": "a3"}})).unwrap();
+ assert_eq!(sheet.orientation, Orientation::Landscape);
+ assert_eq!(sheet.size_mm().unwrap(), Vec2::new(420.0, 297.0));
+ for size in PaperSize::ALL {
+ let across = Sheet::standard(size, Orientation::Landscape).size_mm().unwrap();
+ let upright = Sheet::standard(size, Orientation::Portrait).size_mm().unwrap();
+ assert!(across.x > across.y && upright.x < upright.y, "{size:?}");
+ assert_eq!(across, Vec2::new(upright.y, upright.x));
+ }
+ // A custom sheet's sides may come in either order; the orientation lays it.
+ for sides_mm in [[500.0, 700.0], [700.0, 500.0]] {
+ let sheet = Sheet { size: SheetSize::Custom { sides_mm }, orientation: Orientation::Portrait };
+ assert_eq!(sheet.size_mm().unwrap(), Vec2::new(500.0, 700.0));
+ }
+}
+
+#[test]
+fn a3_landscape_has_a_400_by_277_drawing_border_and_8_by_6_fields() {
+ let layout = iso_layout(PaperSize::A3, Orientation::Landscape);
+ assert_eq!(layout.sheet_border, Aabb2 { min: Vec2::ZERO, max: Vec2::new(420.0, 297.0) });
+ assert_eq!(layout.drawing_border, Aabb2 { min: Vec2::new(10.0, 10.0), max: Vec2::new(410.0, 287.0) });
+ assert_eq!(layout.drawing_border_line_mm, 0.7);
+ // Columns: 50 mm out from the centre line at 210, which is 200 mm from either side: four fields
+ // each way, and nothing left over for the corners.
+ assert!(close(&lengths(&layout.columns), &[50.0; 8]));
+ assert_eq!(layout.columns.iter().map(|f| f.label.as_str()).collect::<Vec<_>>(), ["1", "2", "3", "4", "5", "6", "7", "8"]);
+ assert!(layout.columns.iter().any(|f| f.to_mm == 210.0));
+ // Rows: 148.5 above and below 10 and 287, so two of 50 and a 38.5 mm corner each way.
+ assert!(close(&lengths(&layout.rows), &[38.5, 50.0, 50.0, 50.0, 50.0, 38.5]));
+ assert_eq!(layout.rows.iter().map(|f| f.label.as_str()).collect::<Vec<_>>(), ["A", "B", "C", "D", "E", "F"]);
+ let (top, bottom) = (layout.rows.first().unwrap(), layout.rows.last().unwrap());
+ assert_eq!((top.from_mm, top.to_mm), (248.5, 287.0));
+ assert_eq!((bottom.from_mm, bottom.to_mm), (10.0, 48.5));
+ assert_eq!(layout.label_sides, Sides::ALL);
+}
+
+#[test]
+fn a3_landscape_has_a_grid_border_and_centring_marks_across_the_margin() {
+ let layout = iso_layout(PaperSize::A3, Orientation::Landscape);
+ // 5 mm outside the drawing border (10, 10)-(410, 287).
+ assert_eq!(layout.grid_border, Aabb2 { min: Vec2::new(5.0, 5.0), max: Vec2::new(415.0, 292.0) });
+ // On the centre lines x = 210 and y = 148.5, from the sheet's edge to the drawing border.
+ let mark = |a: (f64, f64), b: (f64, f64)| [Vec2::new(a.0, a.1), Vec2::new(b.0, b.1)];
+ assert_eq!(
+ layout.centring_marks,
+ [
+ mark((210.0, 0.0), (210.0, 10.0)),
+ mark((210.0, 297.0), (210.0, 287.0)),
+ mark((0.0, 148.5), (10.0, 148.5)),
+ mark((420.0, 148.5), (410.0, 148.5))
+ ]
+ );
+ // From the grid reference border instead, when the profile asks.
+ let iso_start = DrawingBorderProfile { centring_mark_start: CentringMarkStart::GridBorder, ..DrawingBorderProfile::iso() };
+ let from_grid = iso_start.layout(&Sheet::standard(PaperSize::A3, Orientation::Landscape)).unwrap();
+ assert_eq!(from_grid.centring_marks[0], mark((210.0, 5.0), (210.0, 10.0)));
+ assert_eq!(from_grid.centring_marks[3], mark((415.0, 148.5), (410.0, 148.5)));
+ assert!(layout.trimming_marks.is_empty());
+ // On the sheet's centre lines, not the drawing border's: a deeper bottom margin leaves them at 148.5.
+ let sheet = Sheet::standard(PaperSize::A3, Orientation::Landscape);
+ let iso = DrawingBorderProfile::iso();
+ let deep = DrawingBorderProfile { margins: Margins { bottom_mm: 30.0, ..iso.margins }, ..iso }.layout(&sheet).unwrap();
+ assert!(deep.centring_marks.iter().skip(2).all(|[a, b]| a.y == 148.5 && b.y == 148.5), "{:?}", deep.centring_marks);
+ // A profile can leave the centring marks out.
+ let plain = DrawingBorderProfile { centring_mark_mm: None, ..iso }.layout(&sheet).unwrap();
+ assert!(plain.centring_marks.is_empty());
+ assert_eq!(plain.grid_border, layout.grid_border);
+}
+
+/// A profile can still ask for all of ISO 5457's border: on A3 the drawing border, fields and marks
+/// are the standard's.
+#[test]
+fn a3_landscape_with_iso_5457s_full_border_has_its_filing_margin_and_every_mark() {
+ let layout = full_iso_5457().layout(&Sheet::standard(PaperSize::A3, Orientation::Landscape)).unwrap();
+ // ISO 5457's 390 x 277 drawing space; the left corner field takes the 40 mm left over.
+ assert_eq!(layout.drawing_border, Aabb2 { min: Vec2::new(20.0, 10.0), max: Vec2::new(410.0, 287.0) });
+ assert!(close(&lengths(&layout.columns), &[40.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0]));
+ assert!(close(&lengths(&layout.rows), &[38.5, 50.0, 50.0, 50.0, 50.0, 38.5]));
+ // 5 mm outside the drawing border, the left side too.
+ assert_eq!(layout.grid_border, Aabb2 { min: Vec2::new(15.0, 5.0), max: Vec2::new(415.0, 292.0) });
+ // From the grid reference border to 10 mm inside the drawing border.
+ let mark = |a: (f64, f64), b: (f64, f64)| [Vec2::new(a.0, a.1), Vec2::new(b.0, b.1)];
+ assert_eq!(
+ layout.centring_marks,
+ [
+ mark((210.0, 5.0), (210.0, 20.0)),
+ mark((210.0, 292.0), (210.0, 277.0)),
+ mark((15.0, 148.5), (30.0, 148.5)),
+ mark((415.0, 148.5), (400.0, 148.5))
+ ]
+ );
+ // At each corner, 10 along the bottom or top edge by 5 up or down, and 5 by 10 along the side.
+ let rect = |x0, y0, x1, y1| Aabb2 { min: Vec2::new(x0, y0), max: Vec2::new(x1, y1) };
+ assert_eq!(
+ layout.trimming_marks,
+ [
+ rect(0.0, 0.0, 10.0, 5.0),
+ rect(0.0, 0.0, 5.0, 10.0),
+ rect(410.0, 0.0, 420.0, 5.0),
+ rect(415.0, 0.0, 420.0, 10.0),
+ rect(0.0, 292.0, 10.0, 297.0),
+ rect(0.0, 287.0, 5.0, 297.0),
+ rect(410.0, 292.0, 420.0, 297.0),
+ rect(415.0, 287.0, 420.0, 297.0),
+ ]
+ );
+}
+
+/// On every standard size either way, the marks are where the profile puts them: the built-in
+/// centring marks run from the sheet's edge and end exactly on the drawing border, and there are no
+/// trimming marks; ISO 5457's full border starts them at the grid reference border, reaches 10 mm
+/// inside and has its trimming marks in the corners.
+#[test]
+fn every_sheet_has_centring_marks_on_its_centre_lines_and_trimming_marks_only_when_asked() {
+ for (profile, reach, trimming_marks) in [(DrawingBorderProfile::iso(), 0.0, 0), (full_iso_5457(), 10.0, 8)] {
+ for size in PaperSize::ALL {
+ for orientation in [Orientation::Landscape, Orientation::Portrait] {
+ let layout = profile.layout(&Sheet::standard(size, orientation)).unwrap();
+ let (size_mm, drawing, grid) = (layout.sheet_border.max, layout.drawing_border, layout.grid_border);
+ let centre = Vec2::new(size_mm.x / 2.0, size_mm.y / 2.0);
+ let start = match profile.centring_mark_start {
+ CentringMarkStart::SheetEdge => layout.sheet_border,
+ CentringMarkStart::GridBorder => grid,
+ };
+ // Bottom, top, left and right, from where the profile starts them.
+ let expected = [
+ [Vec2::new(centre.x, start.min.y), Vec2::new(centre.x, drawing.min.y + reach)],
+ [Vec2::new(centre.x, start.max.y), Vec2::new(centre.x, drawing.max.y - reach)],
+ [Vec2::new(start.min.x, centre.y), Vec2::new(drawing.min.x + reach, centre.y)],
+ [Vec2::new(start.max.x, centre.y), Vec2::new(drawing.max.x - reach, centre.y)],
+ ];
+ assert_eq!(layout.centring_marks, expected, "{size:?} {orientation:?} {reach}");
+ assert_eq!(layout.trimming_marks.len(), trimming_marks, "{size:?} {orientation:?}");
+ for (i, r) in layout.trimming_marks.iter().enumerate() {
+ assert!(r.min.x >= 0.0 && r.min.y >= 0.0 && r.max.x <= size_mm.x && r.max.y <= size_mm.y, "{size:?}: {r:?}");
+ let on_corner = (r.min.x == 0.0 || r.max.x == size_mm.x) && (r.min.y == 0.0 || r.max.y == size_mm.y);
+ let shape = if i % 2 == 0 { Vec2::new(10.0, 5.0) } else { Vec2::new(5.0, 10.0) };
+ assert!(on_corner && r.size().dist(shape) < EPS, "{size:?} {orientation:?}: {r:?}");
+ // In the margins: up to the grid reference border, never across it.
+ assert!(!r.inflated(-EPS).meets(&grid), "{size:?} {orientation:?}: {r:?}");
+ }
+ }
+ }
+ }
+}
+
+/// The filing margin puts ISO 5457's 20 mm on the left in either orientation and moves nothing
+/// else; a 20 mm left margin set by hand lays out the same.
+#[test]
+fn the_filing_margin_puts_20_mm_on_the_left_of_every_sheet() {
+ let iso = DrawingBorderProfile::iso();
+ let (filing, by_hand) = (with_filing_margin(), DrawingBorderProfile { margins: Margins { left_mm: 20.0, ..iso.margins }, ..iso });
+ // ISO 5457's drawing spaces: A3 across 390 x 277, A4 upright 180 x 277.
+ let a3 = filing.layout(&Sheet::standard(PaperSize::A3, Orientation::Landscape)).unwrap();
+ assert_eq!(a3.drawing_border, Aabb2 { min: Vec2::new(20.0, 10.0), max: Vec2::new(410.0, 287.0) });
+ assert!(close(&lengths(&a3.columns), &[40.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0]));
+ let a4 = filing.layout(&Sheet::standard(PaperSize::A4, Orientation::Portrait)).unwrap();
+ assert_eq!(a4.drawing_border, Aabb2 { min: Vec2::new(20.0, 10.0), max: Vec2::new(200.0, 287.0) });
+ // 85 mm left of the centre line at 105 and 95 right of it: two fields each way.
+ assert!(close(&lengths(&a4.columns), &[35.0, 50.0, 50.0, 45.0]));
+ for size in PaperSize::ALL {
+ for orientation in [Orientation::Landscape, Orientation::Portrait] {
+ let sheet = Sheet::standard(size, orientation);
+ let (on, off) = (filing.layout(&sheet).unwrap(), iso.layout(&sheet).unwrap());
+ assert_eq!(on, by_hand.layout(&sheet).unwrap(), "{size:?} {orientation:?}");
+ assert_eq!((on.drawing_border.min.x, off.drawing_border.min.x), (20.0, 10.0), "{size:?} {orientation:?}");
+ assert_eq!((on.drawing_border.min.y, on.drawing_border.max), (off.drawing_border.min.y, off.drawing_border.max));
+ assert_eq!(on.rows, off.rows, "{size:?} {orientation:?}");
+ }
+ }
+ // A left margin set by hand is kept for when the filing margin is off again.
+ let a3 = Sheet::standard(PaperSize::A3, Orientation::Landscape);
+ let wide = DrawingBorderProfile { margins: Margins { left_mm: 30.0, ..iso.margins }, ..iso };
+ assert_eq!(DrawingBorderProfile { filing_margin: true, ..wide }.layout(&a3).unwrap().drawing_border.min.x, 20.0);
+ assert_eq!(wide.layout(&a3).unwrap().drawing_border.min.x, 30.0);
+}
+
+#[test]
+fn the_iso_rule_gives_the_standard_field_counts_for_a0_to_a4_either_way() {
+ // ISO 5457's table, long side by short side, with the filing margin or without.
+ for profile in [DrawingBorderProfile::iso(), with_filing_margin()] {
+ for (size, long, short) in
+ [(PaperSize::A0, 24, 16), (PaperSize::A1, 16, 12), (PaperSize::A2, 12, 8), (PaperSize::A3, 8, 6), (PaperSize::A4, 6, 4)]
+ {
+ let across = profile.layout(&Sheet::standard(size, Orientation::Landscape)).unwrap();
+ assert_eq!((across.columns.len(), across.rows.len()), (long, short), "{size:?} landscape {profile:?}");
+ let upright = profile.layout(&Sheet::standard(size, Orientation::Portrait)).unwrap();
+ assert_eq!((upright.columns.len(), upright.rows.len()), (short, long), "{size:?} portrait {profile:?}");
+ }
+ }
+ // A1 across: 410.5 mm each side of the centre line, so eight fields each way and 60.5 mm corners;
+ // the filing margin leaves 400.5 on the left, a 50.5 mm corner.
+ let a1 = Sheet::standard(PaperSize::A1, Orientation::Landscape);
+ for (profile, left) in [(DrawingBorderProfile::iso(), 60.5), (with_filing_margin(), 50.5)] {
+ let widths = lengths(&profile.layout(&a1).unwrap().columns);
+ assert!((widths.first().unwrap() - left).abs() < EPS && (widths.last().unwrap() - 60.5).abs() < EPS, "{widths:?}");
+ }
+}
+
+/// The label sides are worked out for each sheet, so one profile labels every size as ISO 5457 does.
+#[test]
+fn one_iso_profile_labels_a4_on_its_top_and_right_and_every_other_size_all_round() {
+ let iso = DrawingBorderProfile::iso();
+ let top_right = Sides { top: true, bottom: false, left: false, right: true };
+ let bottom_left = Sides { top: false, bottom: true, left: true, right: false };
+ let fixed = DrawingBorderProfile { label_sides: LabelSides::Fixed(bottom_left), ..iso };
+ for size in PaperSize::ALL {
+ for orientation in [Orientation::Portrait, Orientation::Landscape] {
+ let sheet = Sheet::standard(size, orientation);
+ let expected = if size == PaperSize::A4 { top_right } else { Sides::ALL };
+ assert_eq!(iso.layout(&sheet).unwrap().label_sides, expected, "{size:?} {orientation:?}");
+ assert_eq!(fixed.layout(&sheet).unwrap().label_sides, bottom_left, "{size:?} {orientation:?}");
+ }
+ }
+}
+
+#[test]
+fn an_equal_division_cuts_the_drawing_border_evenly() {
+ let sheet = Sheet::standard(PaperSize::A3, Orientation::Landscape);
+ // With the filing margin, so the 390 mm across isn't a whole number of 50 mm fields.
+ let profile = DrawingBorderProfile { grid: GridRule::Equal { columns: 8, rows: 6 }, ..with_filing_margin() };
+ let layout = profile.layout(&sheet).unwrap();
+ assert!(close(&lengths(&layout.columns), &[48.75; 8]));
+ assert!(close(&lengths(&layout.rows), &[277.0 / 6.0; 6]));
+ assert!((277.0 / 6.0 - 46.166_666_666_7_f64).abs() < 1e-9);
+ let none = DrawingBorderProfile { grid: GridRule::None, ..profile }.layout(&sheet).unwrap();
+ assert!(none.columns.is_empty() && none.rows.is_empty());
+ assert_eq!(none.drawing_border, layout.drawing_border);
+}
+
+#[test]
+fn rows_skip_i_and_o_and_letters_go_on_past_z() {
+ let a0 = iso_layout(PaperSize::A0, Orientation::Landscape);
+ let rows: String = a0.rows.iter().map(|f| f.label.as_str()).collect();
+ assert_eq!(rows, "ABCDEFGHJKLMNPQR");
+ assert_eq!(letters(0, true), "A");
+ assert_eq!(letters(23, true), "Z");
+ assert_eq!(letters(24, true), "AA");
+ assert_eq!(letters(25, true), "AB");
+ assert_eq!(letters(24 + 24 * 24 - 1, true), "ZZ");
+ assert_eq!(letters(24 + 24 * 24, true), "AAA");
+ assert_eq!(letters(8, false), "I");
+ assert_eq!(letters(25, false), "Z");
+ assert_eq!(letters(26, false), "AA");
+ assert_eq!(letters(usize::MAX, true).len(), letters(usize::MAX - 1, true).len());
+ for i in 0..2000 {
+ assert!(!letters(i, true).contains(['I', 'O']), "{i}");
+ }
+ let sheet = Sheet::standard(PaperSize::A3, Orientation::Landscape);
+ let every = DrawingBorderProfile { skip_i_and_o: false, grid: GridRule::Equal { columns: 1, rows: 10 }, ..DrawingBorderProfile::iso() };
+ let rows: String = every.layout(&sheet).unwrap().rows.iter().map(|f| f.label.as_str()).collect();
+ assert_eq!(rows, "ABCDEFGHIJ");
+}
+
+#[test]
+fn hostile_sizes_and_profiles_are_refused() {
+ let custom = |a: f64, b: f64| Sheet { size: SheetSize::Custom { sides_mm: [a, b] }, orientation: Orientation::Landscape };
+ for (a, b) in [(0.0, 100.0), (-1.0, 100.0), (f64::NAN, 100.0), (100.0, f64::INFINITY), (5_000.000_001, 100.0), (f64::MIN_POSITIVE, f64::MAX)] {
+ assert!(custom(a, b).size_mm().is_err(), "{a} x {b}");
+ }
+ assert_eq!(custom(5000.0, 5000.0).size_mm().unwrap(), Vec2::new(5000.0, 5000.0));
+ let a3 = Sheet::standard(PaperSize::A3, Orientation::Landscape);
+ let iso = DrawingBorderProfile::iso();
+ let with_margins =
+ |left_mm, right_mm, top_mm, bottom_mm| DrawingBorderProfile { margins: Margins { left_mm, right_mm, top_mm, bottom_mm }, ..iso };
+ // Refused on its own, with no sheet at all: validate() refuses it, and so layout() does too.
+ for profile in [
+ with_margins(-1.0, 10.0, 10.0, 10.0),
+ with_margins(f64::NAN, 10.0, 10.0, 10.0),
+ with_margins(20.0, f64::INFINITY, 10.0, 10.0),
+ with_margins(20.0, 10.0, 5000.1, 10.0),
+ // The left margin is checked while the filing margin stands in for it.
+ DrawingBorderProfile { filing_margin: true, ..with_margins(f64::NAN, 10.0, 10.0, 10.0) },
+ DrawingBorderProfile { filing_margin: true, ..with_margins(-1.0, 10.0, 10.0, 10.0) },
+ DrawingBorderProfile { drawing_border_line_mm: 0.0, ..iso },
+ DrawingBorderProfile { drawing_border_line_mm: -0.7, ..iso },
+ DrawingBorderProfile { drawing_border_line_mm: f64::NAN, ..iso },
+ DrawingBorderProfile { drawing_border_line_mm: 10.000_001, ..iso },
+ DrawingBorderProfile { grid: GridRule::FromCentre { field_mm: 0.999 }, ..iso },
+ DrawingBorderProfile { grid: GridRule::FromCentre { field_mm: 1000.1 }, ..iso },
+ DrawingBorderProfile { grid: GridRule::FromCentre { field_mm: f64::NAN }, ..iso },
+ DrawingBorderProfile { grid: GridRule::FromCentre { field_mm: f64::INFINITY }, ..iso },
+ DrawingBorderProfile { grid: GridRule::Equal { columns: 0, rows: 6 }, ..iso },
+ DrawingBorderProfile { grid: GridRule::Equal { columns: 8, rows: 0 }, ..iso },
+ DrawingBorderProfile { grid: GridRule::Equal { columns: 201, rows: 1 }, ..iso },
+ DrawingBorderProfile { grid: GridRule::Equal { columns: u32::MAX, rows: u32::MAX }, ..iso },
+ // The grid reference border lies between the sheet border and the drawing border.
+ DrawingBorderProfile { grid_border_mm: -0.1, ..iso },
+ DrawingBorderProfile { grid_border_mm: f64::NAN, ..iso },
+ DrawingBorderProfile { grid_border_mm: 10.000_001, ..iso },
+ // On every side: 5 mm is wider than a 4 mm bottom margin, or a 4 mm left one without the
+ // filing margin.
+ with_margins(20.0, 10.0, 10.0, 4.0),
+ with_margins(4.0, 10.0, 10.0, 10.0),
+ // A centring mark ends on the drawing border or inside it...
+ DrawingBorderProfile { centring_mark_mm: Some(-0.000_001), ..iso },
+ DrawingBorderProfile { centring_mark_mm: Some(-10.0), ..iso },
+ DrawingBorderProfile { centring_mark_mm: Some(f64::NAN), ..iso },
+ DrawingBorderProfile { centring_mark_mm: Some(f64::INFINITY), ..iso },
+ // No mark is longer than the largest sheet's side, so a file's huge number is refused when
+ // read rather than saved as one the next read refuses.
+ DrawingBorderProfile { centring_mark_mm: Some(5_000.000_001), ..iso },
+ DrawingBorderProfile { centring_mark_mm: Some(u64::MAX as f64), ..iso },
+ // ...and is longer than 0: one that stops on the drawing border needs room outside it on
+ // the side it starts from, a grid reference border or every margin.
+ DrawingBorderProfile { grid_border_mm: 0.0, centring_mark_start: CentringMarkStart::GridBorder, ..iso },
+ DrawingBorderProfile { grid_border_mm: 0.0, ..with_margins(0.0, 10.0, 10.0, 10.0) },
+ // A trimming mark is finite, above 0 and no wider than it is long...
+ DrawingBorderProfile { trimming_mark_mm: Some([4.0, 5.0]), ..iso },
+ DrawingBorderProfile { trimming_mark_mm: Some([10.0, 0.0]), ..iso },
+ DrawingBorderProfile { trimming_mark_mm: Some([f64::NAN, 5.0]), ..iso },
+ DrawingBorderProfile { trimming_mark_mm: Some([10.0, f64::NAN]), ..iso },
+ DrawingBorderProfile { trimming_mark_mm: Some([f64::INFINITY, 5.0]), ..iso },
+ DrawingBorderProfile { trimming_mark_mm: Some([5_000.000_001, 5.0]), ..iso },
+ DrawingBorderProfile { trimming_mark_mm: Some([u64::MAX as f64, 5.0]), ..iso },
+ // ...and fits between the sheet border and the grid reference border: ISO 5457's 5 mm fill
+ // the 10 - 5 mm left exactly.
+ DrawingBorderProfile { grid_border_mm: 5.000_001, ..full_iso_5457() },
+ DrawingBorderProfile { grid_border_mm: 0.0, centring_mark_mm: None, trimming_mark_mm: Some([10.0, 5.0]), ..with_margins(2.0, 2.0, 2.0, 2.0) },
+ ] {
+ assert!(profile.validate().is_err(), "validated {profile:?}");
+ assert!(profile.layout(&a3).is_err(), "laid out {profile:?}");
+ }
+ // Fine on its own, but not on an A3 sheet.
+ for profile in [
+ with_margins(210.0, 210.0, 10.0, 10.0),
+ with_margins(20.0, 10.0, 148.0, 148.5),
+ // A millimetre of drawing space, but the centre line at 210 lies outside it.
+ with_margins(200.0, 219.0, 10.0, 10.0),
+ // A centring mark past the centre line, 138.5 mm inside the drawing border's bottom.
+ DrawingBorderProfile { centring_mark_mm: Some(138.500_001), ..iso },
+ // Or a drawing border its centre lines miss.
+ DrawingBorderProfile { grid: GridRule::Equal { columns: 2, rows: 2 }, ..with_margins(200.0, 219.0, 10.0, 10.0) },
+ // Or one whose left side lies on the centre line at 210, with any reach inside it.
+ DrawingBorderProfile {
+ grid: GridRule::Equal { columns: 2, rows: 2 },
+ centring_mark_mm: Some(0.000_001),
+ ..with_margins(210.0, 10.0, 10.0, 10.0)
+ },
+ // A trimming mark longer than half the 297 mm side.
+ DrawingBorderProfile { trimming_mark_mm: Some([148.500_001, 5.0]), ..iso },
+ // The longest marks a profile may have, on the largest sheet only.
+ DrawingBorderProfile { centring_mark_mm: Some(5000.0), ..iso },
+ DrawingBorderProfile { trimming_mark_mm: Some([5000.0, 5.0]), ..iso },
+ ] {
+ assert_eq!(profile.validate(), Ok(()), "{profile:?}");
+ assert!(profile.layout(&a3).is_err(), "laid out {profile:?}");
+ }
+ // The same space with an equal division and no centring marks is fine, and so are the limits
+ // themselves.
+ let off_centre =
+ DrawingBorderProfile { grid: GridRule::Equal { columns: 2, rows: 2 }, centring_mark_mm: None, ..with_margins(200.0, 219.0, 10.0, 10.0) };
+ assert!((off_centre.layout(&a3).unwrap().drawing_border.max.x - 201.0).abs() < EPS);
+ for profile in [
+ DrawingBorderProfile { drawing_border_line_mm: 10.0, ..iso },
+ DrawingBorderProfile { grid: GridRule::FromCentre { field_mm: 1.0 }, ..iso },
+ DrawingBorderProfile { grid: GridRule::FromCentre { field_mm: 1000.0 }, ..iso },
+ DrawingBorderProfile { grid: GridRule::Equal { columns: 200, rows: 200 }, ..iso },
+ DrawingBorderProfile { grid_border_mm: 0.0, centring_mark_mm: None, ..with_margins(0.0, 0.0, 0.0, 0.0) },
+ DrawingBorderProfile { grid_border_mm: 10.0, ..iso },
+ DrawingBorderProfile { centring_mark_mm: Some(138.5), ..iso },
+ // With no grid reference border, a centring mark that reaches inside has a length, and so
+ // does one from the sheet's edge.
+ DrawingBorderProfile { grid_border_mm: 0.0, centring_mark_mm: Some(10.0), centring_mark_start: CentringMarkStart::GridBorder, ..iso },
+ DrawingBorderProfile { grid_border_mm: 0.0, ..iso },
+ // A centre line on the drawing border's left side: a mark that stops on the border fits.
+ DrawingBorderProfile { grid: GridRule::Equal { columns: 2, rows: 2 }, ..with_margins(210.0, 10.0, 10.0, 10.0) },
+ // The filing margin stands in for a left margin too narrow for the grid reference border.
+ DrawingBorderProfile { filing_margin: true, ..with_margins(4.0, 10.0, 10.0, 10.0) },
+ iso,
+ // ISO 5457's trimming marks fill their strip exactly, and so do these.
+ full_iso_5457(),
+ DrawingBorderProfile { grid_border_mm: 0.0, centring_mark_mm: None, trimming_mark_mm: Some([10.0, 2.0]), ..with_margins(2.0, 2.0, 2.0, 2.0) },
+ DrawingBorderProfile { trimming_mark_mm: Some([148.5, 5.0]), ..iso },
+ ] {
+ profile.layout(&a3).unwrap();
+ }
+}
+
+#[test]
+fn names_round_trip_and_unknown_fields_are_refused() {
+ for (size, name) in
+ [(PaperSize::A0, "a0"), (PaperSize::A5, "a5"), (PaperSize::Letter, "letter"), (PaperSize::AnsiA, "ansi_a"), (PaperSize::ArchE1, "arch_e1")]
+ {
+ assert_eq!(serde_json::to_value(size).unwrap(), serde_json::json!(name));
+ }
+ for size in PaperSize::ALL {
+ let back: PaperSize = serde_json::from_value(serde_json::to_value(size).unwrap()).unwrap();
+ assert_eq!(back, size);
+ }
+ let sheet = Sheet { size: SheetSize::Custom { sides_mm: [500.0, 700.0] }, orientation: Orientation::Portrait };
+ let value = serde_json::to_value(sheet).unwrap();
+ assert_eq!(value, serde_json::json!({"size": {"custom": {"sides_mm": [500.0, 700.0]}}, "orientation": "portrait"}));
+ assert_eq!(serde_json::from_value::<Sheet>(value).unwrap(), sheet);
+ let profile = DrawingBorderProfile::iso();
+ let value = serde_json::to_value(profile).unwrap();
+ assert_eq!(value["margins"], serde_json::json!({"left_mm": 10.0, "right_mm": 10.0, "top_mm": 10.0, "bottom_mm": 10.0}));
+ assert_eq!(value["filing_margin"], serde_json::json!(false));
+ assert_eq!(value["grid"], serde_json::json!({"from_centre": {"field_mm": 50.0}}));
+ assert_eq!(value["label_sides"], serde_json::json!("iso"));
+ assert_eq!(value["centring_mark_mm"], serde_json::json!(0.0));
+ assert_eq!(value["centring_mark_start"], serde_json::json!("sheet_edge"));
+ // Not given, it is the sheet's edge; an unknown start is refused.
+ let mut without = value.clone();
+ without.as_object_mut().unwrap().remove("centring_mark_start");
+ assert_eq!(serde_json::from_value::<DrawingBorderProfile>(without).unwrap(), profile);
+ let mut unknown = value.clone();
+ unknown["centring_mark_start"] = serde_json::json!("middle");
+ assert!(serde_json::from_value::<DrawingBorderProfile>(unknown).is_err());
+ assert_eq!(value["trimming_mark_mm"], serde_json::json!(null));
+ assert_eq!(serde_json::to_value(GridRule::None).unwrap(), serde_json::json!("none"));
+ assert_eq!(serde_json::from_value::<DrawingBorderProfile>(value.clone()).unwrap(), profile);
+ for other in [
+ DrawingBorderProfile { grid: GridRule::None, ..profile },
+ DrawingBorderProfile { grid: GridRule::Equal { columns: 8, rows: 6 }, ..profile },
+ DrawingBorderProfile { label_sides: LabelSides::Fixed(Sides::ALL), ..profile },
+ full_iso_5457(),
+ ] {
+ assert_eq!(serde_json::from_value::<DrawingBorderProfile>(serde_json::to_value(other).unwrap()).unwrap(), other);
+ }
+ // A profile written without the filing margin reads with it off.
+ let mut without = value.clone();
+ without.as_object_mut().unwrap().remove("filing_margin");
+ assert_eq!(serde_json::from_value::<DrawingBorderProfile>(without).unwrap(), profile);
+ for bad in [
+ serde_json::json!({"size": {"standard": "a6"}}),
+ serde_json::json!({"size": {"standard": "a3"}, "scale": 1}),
+ serde_json::json!({"size": {"custom": {"sides_mm": [1, 2], "units": "in"}}}),
+ serde_json::json!({"size": {"custom": {"sides_mm": [1, 2, 3]}}}),
+ serde_json::json!({"size": {"standard": "a3"}, "orientation": "upside_down"}),
+ ] {
+ assert!(serde_json::from_value::<Sheet>(bad.clone()).is_err(), "{bad}");
+ }
+ // An unknown field anywhere in a profile is refused, in the grid's `none` form too.
+ for (key, bad) in [
+ ("title_block", serde_json::json!(true)),
+ ("grid", serde_json::json!({"rule": "none", "columns": 8})),
+ ("grid", serde_json::json!({"none": {"columns": 8}})),
+ ("grid", serde_json::json!({"from_centre": {"field_mm": 50.0, "columns": 8}})),
+ ("grid", serde_json::json!({"from_centre": {"field_mm": 50.0}, "columns": 8})),
+ ("label_sides", serde_json::json!({"fixed": {"top": true, "bottom": true, "left": true, "right": true, "middle": true}})),
+ ] {
+ let mut extra = value.clone();
+ extra[key] = bad.clone();
+ assert!(serde_json::from_value::<DrawingBorderProfile>(extra).is_err(), "{key}: {bad}");
+ }
+}
+
+/// For every accepted sheet and profile, the fields tile the drawing border exactly, top to bottom
+/// and left to right, every field is longer than nothing and nothing is NaN.
+#[test]
+fn fields_tile_every_drawing_border_exactly() {
+ let mut sheets: Vec<Sheet> =
+ PaperSize::ALL.into_iter().flat_map(|size| [Orientation::Landscape, Orientation::Portrait].map(|o| Sheet::standard(size, o))).collect();
+ for sides_mm in [[1.5, 1.5], [5000.0, 5000.0], [5000.0, 1.0], [17.3, 4999.9], [100.0, 101.0], [123.456, 789.012]] {
+ for orientation in [Orientation::Landscape, Orientation::Portrait] {
+ sheets.push(Sheet { size: SheetSize::Custom { sides_mm }, orientation });
+ }
+ }
+ let margins = [
+ Margins { left_mm: 20.0, right_mm: 10.0, top_mm: 10.0, bottom_mm: 10.0 },
+ Margins { left_mm: 0.0, right_mm: 0.0, top_mm: 0.0, bottom_mm: 0.0 },
+ Margins { left_mm: 5.0, right_mm: 5.0, top_mm: 5.0, bottom_mm: 5.0 },
+ Margins { left_mm: 33.3, right_mm: 0.1, top_mm: 7.7, bottom_mm: 19.0 },
+ ];
+ let grids = [
+ GridRule::FromCentre { field_mm: 50.0 },
+ GridRule::FromCentre { field_mm: 1.0 },
+ GridRule::FromCentre { field_mm: 7.5 },
+ GridRule::FromCentre { field_mm: 33.3 },
+ GridRule::FromCentre { field_mm: 1000.0 },
+ GridRule::Equal { columns: 1, rows: 1 },
+ GridRule::Equal { columns: 3, rows: 7 },
+ GridRule::Equal { columns: 200, rows: 200 },
+ ];
+ let mut accepted = 0;
+ for sheet in &sheets {
+ for (margins, filing_margin) in margins.into_iter().flat_map(|m| [(m, false), (m, true)]) {
+ for grid in grids {
+ let profile = DrawingBorderProfile {
+ margins,
+ filing_margin,
+ drawing_border_line_mm: 0.7,
+ grid,
+ skip_i_and_o: true,
+ label_sides: LabelSides::Fixed(Sides::ALL),
+ grid_border_mm: 0.0,
+ centring_mark_mm: None,
+ centring_mark_start: CentringMarkStart::SheetEdge,
+ trimming_mark_mm: None,
+ };
+ let Ok(layout) = profile.layout(sheet) else { continue };
+ accepted += 1;
+ let (drawing, size_mm) = (layout.drawing_border, layout.sheet_border.max);
+ assert!(drawing.min.x >= 0.0 && drawing.min.y >= 0.0 && drawing.max.x <= size_mm.x && drawing.max.y <= size_mm.y);
+ let check = |fields: &[Field], lo: f64, hi: f64, falling: bool| {
+ let (first, last) = (fields.first().unwrap(), fields.last().unwrap());
+ let (start, end) = if falling { (last.from_mm, first.to_mm) } else { (first.from_mm, last.to_mm) };
+ assert_eq!((start, end), (lo, hi), "{sheet:?} {profile:?}");
+ for f in fields {
+ assert!(f.from_mm.is_finite() && f.to_mm.is_finite() && f.to_mm - f.from_mm > EPS, "{f:?} {sheet:?} {profile:?}");
+ }
+ for w in fields.windows(2) {
+ let (a, b) = (&w[0], &w[1]);
+ if falling { assert_eq!(a.from_mm, b.to_mm) } else { assert_eq!(a.to_mm, b.from_mm) }
+ }
+ let total: f64 = fields.iter().map(|f| f.to_mm - f.from_mm).sum();
+ assert!((total - (hi - lo)).abs() < 1e-6, "{total} vs {}", hi - lo);
+ let mut labels: Vec<&str> = fields.iter().map(|f| f.label.as_str()).collect();
+ labels.sort_unstable();
+ labels.dedup();
+ assert_eq!(labels.len(), fields.len());
+ };
+ check(&layout.columns, drawing.min.x, drawing.max.x, false);
+ check(&layout.rows, drawing.min.y, drawing.max.y, true);
+ if let GridRule::FromCentre { field_mm } = grid {
+ // Inner fields are exactly the field length, and the centre lines are edges.
+ let centre = size_mm.x / 2.0;
+ assert!(layout.columns.iter().any(|f| f.to_mm == centre));
+ let inner = layout.columns.len().saturating_sub(2);
+ for f in layout.columns.iter().skip(1).take(inner) {
+ assert!((f.to_mm - f.from_mm - field_mm).abs() < 1e-9, "{f:?}");
+ }
+ }
+ }
+ }
+ }
+ assert!(accepted > 1000, "{accepted}");
+}
+
+#[test]
+fn rounding_past_a_whole_number_of_fields_leaves_no_sliver() {
+ // 420 mm across with the centre line at 210 and the drawing border to 410: the right half is
+ // four fields of 50. The left margin puts the left half at 150 mm, three fields, give or take
+ // rounding noise.
+ let sheet = Sheet { size: SheetSize::Custom { sides_mm: [420.0, 297.0] }, orientation: Orientation::Landscape };
+ for hair in [0.0, 1e-12, 1e-10, -1e-10] {
+ let margins = Margins { left_mm: 60.0 - hair, right_mm: 10.0, top_mm: 10.0, bottom_mm: 10.0 };
+ let layout = DrawingBorderProfile { margins, ..DrawingBorderProfile::iso() }.layout(&sheet).unwrap();
+ let widths = lengths(&layout.columns);
+ // The noise joins the corner field: no field of a hair's width before it.
+ assert_eq!(widths.len(), 7, "{hair}: {widths:?}");
+ assert!(close(&widths, &[50.0; 7]), "{hair}: {widths:?}");
+ assert_eq!(layout.columns.first().unwrap().from_mm, 60.0 - hair);
+ }
+}
diff --git a/crates/geom/src/drawing_view.rs b/crates/geom/src/drawing_view.rs
new file mode 100644
index 0000000000..4459c10db3
--- /dev/null
+++ b/crates/geom/src/drawing_view.rs
@@ -0,0 +1,291 @@
+//! Drawing views as data (W17a, #4816): which way a view looks, its scale, and the map from the
+//! model's millimetres to the paper's. Nothing here draws or measures; the view commands (W07)
+//! and the hidden-line and section producers feed it.
+//!
+//! - A view's **basis** is a [`Plane`]: paper x along `x`, paper y along `y`, and its normal
+//! `x × y` toward the viewer. [`NamedView`] gives the principal views and the four upper
+//! isometric corners exactly, never from a camera, which tilts a top view by its pitch clamp;
+//! [`basis_looking`] gives any other view from its direction and up.
+//! - A **[`Scale`]** is a ratio of two numbers from 0.000001 to 1000000, written `"1:2"` (paper :
+//! model), from 1:100000 to 1000:1. [`Scale::fit`] picks the largest of ISO 5455's preset
+//! scales at which a view fits a space.
+//! - A **[`ViewFrame`]** places a view on paper: the point of the view's plane at `centre` lands at
+//! `position_mm`, everything scaled by the scale. Its [`ViewFrame::paper_map`] moves the view's
+//! curves ([`Seg2::similar`]) and their accuracy ([`CurveAccuracy::scaled`]) onto paper.
+
+use std::fmt;
+use std::str::FromStr;
+
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+use crate::paper::MAX_SIDE_MM;
+use crate::section::{CurveAccuracy, MAX_NUMBER, validate_plane};
+use crate::{Aabb2, Plane, Seg2, Similarity2, Vec2, Vec3};
+
+/// The smallest scale: one paper millimetre for 100 m of model.
+pub const MIN_SCALE: f64 = 1e-5;
+/// The largest scale: 1000 paper millimetres for one of model.
+pub const MAX_SCALE: f64 = 1000.0;
+/// The smallest and largest number either side of a scale may be: `"1:100000"` and `"1000:1"`
+/// with room to spare, and never more than about 50 characters written out.
+pub const MIN_PART: f64 = 1e-6;
+pub const MAX_PART: f64 = 1e6;
+
+#[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
+#[error("drawing view: {0}")]
+pub struct Invalid(pub &'static str);
+
+type Result<T> = std::result::Result<T, Invalid>;
+
+fn require(condition: bool, message: &'static str) -> Result<()> {
+ if condition { Ok(()) } else { Err(Invalid(message)) }
+}
+
+/// Two directions closer to parallel than this (the sine of their angle) give no view.
+const PARALLEL: f64 = 1e-9;
+
+/// A view with a name: the six principal views and the isometric views from the four upper
+/// corners. Each looks at the model from where its name says; `iso` reads as the front-right one.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum NamedView {
+ Front,
+ Back,
+ Top,
+ Bottom,
+ Left,
+ Right,
+ #[serde(alias = "iso")]
+ IsoFrontRight,
+ IsoFrontLeft,
+ IsoBackRight,
+ IsoBackLeft,
+}
+
+impl NamedView {
+ pub const ALL: [NamedView; 10] = [
+ NamedView::Front,
+ NamedView::Back,
+ NamedView::Top,
+ NamedView::Bottom,
+ NamedView::Left,
+ NamedView::Right,
+ NamedView::IsoFrontRight,
+ NamedView::IsoFrontLeft,
+ NamedView::IsoBackRight,
+ NamedView::IsoBackLeft,
+ ];
+
+ /// The view's basis, through the world origin. The principal views' axes are exact unit
+ /// vectors, with no -0 to write out, each the front view folded about the edge it shares with
+ /// it: the top and bottom views keep paper x along +X (the bottom's y is -Y), and the back and
+ /// side views keep paper y along +Z. An isometric view looks from its corner, `(±1, ±1, 1)`,
+ /// toward the origin, with paper x horizontal (along the view direction × Z) and paper y up.
+ pub fn basis(self) -> Plane {
+ let (x, y) = match self {
+ NamedView::Front => (Vec3::X, Vec3::Z),
+ NamedView::Back => (Vec3::new(-1.0, 0.0, 0.0), Vec3::Z),
+ NamedView::Top => (Vec3::X, Vec3::Y),
+ NamedView::Bottom => (Vec3::X, Vec3::new(0.0, -1.0, 0.0)),
+ NamedView::Left => (Vec3::new(0.0, -1.0, 0.0), Vec3::Z),
+ NamedView::Right => (Vec3::Y, Vec3::Z),
+ NamedView::IsoFrontRight => iso(1.0, -1.0),
+ NamedView::IsoFrontLeft => iso(-1.0, -1.0),
+ NamedView::IsoBackRight => iso(1.0, 1.0),
+ NamedView::IsoBackLeft => iso(-1.0, 1.0),
+ };
+ Plane { origin: Vec3::ZERO, x, y }
+ }
+}
+
+/// The view through `origin` looking along `direction`, with `up` toward the top of the paper:
+/// paper x = direction × up, paper y = x × direction, so the normal points back at the viewer as
+/// the named views' do. `up` need not be square to the direction, only not along it.
+pub fn basis_looking(direction: Vec3, up: Vec3, origin: Vec3) -> Result<Plane> {
+ let d = direction.normalized().ok_or(Invalid("the view direction is zero or not finite"))?;
+ let up = up.normalized().ok_or(Invalid("`up` is zero or not finite"))?;
+ let across = d.cross(up);
+ require(across.len() >= PARALLEL, "`up` lies along the view direction: give another up")?;
+ require(
+ origin.is_finite() && [origin.x, origin.y, origin.z].iter().all(|v| v.abs() <= MAX_NUMBER),
+ "a view's origin is finite and within 1e12 mm of the world's",
+ )?;
+ // Square to the direction again: near the threshold the cross product's rounding is a large
+ // share of its length, which would tilt the normal by up to 1e-8 rad.
+ let across = across - d * across.dot(d);
+ let x = across * (1.0 / across.len());
+ let basis = Plane { origin, x, y: x.cross(d) };
+ validate_plane(&basis).map_err(|_| Invalid("a view's basis is finite and orthonormal"))?;
+ Ok(basis)
+}
+
+/// Paper x and y for an isometric view from the upper corner `(cx, cy, 1)`: x is horizontal, the
+/// view direction × Z, and y = x × direction, so the normal points back at the corner.
+fn iso(cx: f64, cy: f64) -> (Vec3, Vec3) {
+ let toward = Vec3::new(-cx, -cy, -1.0) * (1.0 / 3f64.sqrt());
+ let x = Vec3::new(-cy, cx, 0.0) * (1.0 / 2f64.sqrt());
+ (x, x.cross(toward))
+}
+
+/// A drawing scale, paper : model, as two positive numbers so `"1:3"` stays exactly what was
+/// written. Read and written as that text.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Scale {
+ paper: f64,
+ model: f64,
+}
+
+/// ISO 5455's recommended scales, largest first: enlargements, full size, then reductions.
+pub const PRESETS: [Scale; 18] = [
+ Scale { paper: 50.0, model: 1.0 },
+ Scale { paper: 20.0, model: 1.0 },
+ Scale { paper: 10.0, model: 1.0 },
+ Scale { paper: 5.0, model: 1.0 },
+ Scale { paper: 2.0, model: 1.0 },
+ Scale { paper: 1.0, model: 1.0 },
+ Scale { paper: 1.0, model: 2.0 },
+ Scale { paper: 1.0, model: 5.0 },
+ Scale { paper: 1.0, model: 10.0 },
+ Scale { paper: 1.0, model: 20.0 },
+ Scale { paper: 1.0, model: 50.0 },
+ Scale { paper: 1.0, model: 100.0 },
+ Scale { paper: 1.0, model: 200.0 },
+ Scale { paper: 1.0, model: 500.0 },
+ Scale { paper: 1.0, model: 1000.0 },
+ Scale { paper: 1.0, model: 2000.0 },
+ Scale { paper: 1.0, model: 5000.0 },
+ Scale { paper: 1.0, model: 10000.0 },
+];
+
+impl Scale {
+ /// `paper : model`, each from [`MIN_PART`] to [`MAX_PART`] (so the text stays short), their
+ /// ratio from [`MIN_SCALE`] to [`MAX_SCALE`].
+ pub fn new(paper: f64, model: f64) -> Result<Scale> {
+ let parts = [paper, model].into_iter().all(|v| (MIN_PART..=MAX_PART).contains(&v));
+ let message = "a scale is two numbers from 0.000001 to 1000000, from 1:100000 to 1000:1";
+ require(parts && (MIN_SCALE..=MAX_SCALE).contains(&(paper / model)), message)?;
+ Ok(Scale { paper, model })
+ }
+
+ /// Paper millimetres per model millimetre.
+ pub fn factor(self) -> f64 {
+ self.paper / self.model
+ }
+
+ /// The largest preset at which a view `size_mm` wide and high (in model millimetres) fits
+ /// within `room_mm` on paper, if any does. Compared as `size * paper <= room * model`, so an
+ /// exact fit at 1:5 isn't lost to 0.2's rounding. A size of 0 sets no limit that way (a view of
+ /// a line along the other), so a view of a point fits at the largest preset; a size or room
+ /// that is negative or not finite fits none.
+ pub fn fit(size_mm: Vec2, room_mm: Vec2) -> Option<Scale> {
+ if ![size_mm, room_mm].into_iter().all(|v| v.is_finite() && v.x >= 0.0 && v.y >= 0.0) {
+ return None;
+ }
+ PRESETS.into_iter().find(|s| size_mm.x * s.paper <= room_mm.x * s.model && size_mm.y * s.paper <= room_mm.y * s.model)
+ }
+}
+
+impl fmt::Display for Scale {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "{}:{}", self.paper, self.model)
+ }
+}
+
+/// Plain decimal numbers only (`2`, `2.5`): digits, then at most one point with digits after it;
+/// no sign, exponent or space.
+fn decimal(text: &str) -> Option<f64> {
+ let digits = |s: &str| !s.is_empty() && s.bytes().all(|b| b.is_ascii_digit());
+ let plain = match text.split_once('.') {
+ Some((whole, fraction)) => digits(whole) && digits(fraction),
+ None => digits(text),
+ };
+ plain.then(|| text.parse().ok()).flatten()
+}
+
+impl FromStr for Scale {
+ type Err = Invalid;
+
+ fn from_str(text: &str) -> Result<Scale> {
+ let parts = text.split_once(':').and_then(|(p, m)| Some((decimal(p)?, decimal(m)?)));
+ let (paper, model) = parts.ok_or(Invalid("a scale is written paper:model, such as 1:2"))?;
+ Scale::new(paper, model)
+ }
+}
+
+impl Serialize for Scale {
+ fn serialize<S: Serializer>(&self, s: S) -> std::result::Result<S::Ok, S::Error> {
+ s.collect_str(self)
+ }
+}
+
+impl<'de> Deserialize<'de> for Scale {
+ fn deserialize<D: Deserializer<'de>>(d: D) -> std::result::Result<Scale, D::Error> {
+ String::deserialize(d)?.parse().map_err(serde::de::Error::custom)
+ }
+}
+
+/// A view placed on paper: its basis, its scale, and where it sits.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct ViewFrame {
+ basis: Plane,
+ scale: Scale,
+ map: Similarity2,
+}
+
+impl ViewFrame {
+ /// The view through `basis` at `scale`, with the point `centre` of the view's plane (in its
+ /// own coordinates, [`Plane::to_local`]) at `position_mm` on paper.
+ pub fn new(basis: Plane, scale: Scale, centre: Vec2, position_mm: Vec2) -> Result<ViewFrame> {
+ validate_plane(&basis).map_err(|_| Invalid("a view's basis is finite and orthonormal"))?;
+ require(centre.is_finite() && centre.x.abs() <= MAX_NUMBER && centre.y.abs() <= MAX_NUMBER, "a view's centre is finite")?;
+ let on_paper = position_mm.is_finite() && position_mm.x.abs() <= MAX_SIDE_MM && position_mm.y.abs() <= MAX_SIDE_MM;
+ require(on_paper, "a view's position is finite and at most 5000 mm from the sheet's origin")?;
+ let factor = scale.factor();
+ let map = Similarity2::new(factor, 0.0, position_mm - centre * factor).ok_or(Invalid("a view's position is finite"))?;
+ Ok(ViewFrame { basis, scale, map })
+ }
+
+ pub fn basis(&self) -> Plane {
+ self.basis
+ }
+
+ pub fn scale(&self) -> Scale {
+ self.scale
+ }
+
+ /// The map from the view's plane coordinates to paper millimetres, for its curves. Plane
+ /// coordinates are the plane's own ([`Plane::to_local`]: from the basis's origin along its x
+ /// and y), as section curves are. Points measured along x and y from the world origin (as the
+ /// hidden-line output is planned to be) first lose the origin's own `(origin · x, origin · y)`;
+ /// a named view's origin is the world origin, so for it the two are the same.
+ pub fn paper_map(&self) -> Similarity2 {
+ self.map
+ }
+
+ /// Where a model point appears on paper.
+ pub fn to_paper(&self, p: Vec3) -> Vec2 {
+ self.map.apply(self.basis.to_local(p))
+ }
+
+ /// A box of the view's plane (in plane coordinates, as [`Self::paper_map`]'s) on paper: the box
+ /// around its four corners, mapped. A box that is inside out, or not finite on paper, has none.
+ pub fn boundary(&self, model: &Aabb2) -> Result<Aabb2> {
+ let corners = [model.min, Vec2::new(model.max.x, model.min.y), model.max, Vec2::new(model.min.x, model.max.y)].map(|c| self.map.apply(c));
+ require(!model.is_empty() && corners.iter().all(|c| c.is_finite()), "a view's box is not inside out and is finite on paper")?;
+ Ok(corners.into_iter().collect())
+ }
+
+ /// A curve of the view's plane (in plane coordinates, as [`Self::paper_map`]'s), on paper.
+ pub fn seg_to_paper(&self, seg: &Seg2) -> Seg2 {
+ seg.similar(&self.map)
+ }
+
+ /// A curve's accuracy on paper: its deviation scaled as the curve is.
+ pub fn accuracy_on_paper(&self, accuracy: CurveAccuracy) -> CurveAccuracy {
+ accuracy.scaled(self.map.scale())
+ }
+}
+
+#[cfg(test)]
+#[path = "drawing_view_tests.rs"]
+mod tests;
diff --git a/crates/geom/src/drawing_view_tests.rs b/crates/geom/src/drawing_view_tests.rs
new file mode 100644
index 0000000000..75228a89b7
--- /dev/null
+++ b/crates/geom/src/drawing_view_tests.rs
@@ -0,0 +1,273 @@
+use super::*;
+use crate::section::validate_plane;
+
+const EPS: f64 = 1e-12;
+
+fn close(a: Vec3, b: Vec3) -> bool {
+ (a - b).len() < EPS
+}
+
+/// A 50 mm cube's corners, from the origin.
+fn cube() -> Vec<Vec3> {
+ let s = 50.0;
+ (0..8).map(|i| Vec3::new(f64::from(i & 1) * s, f64::from((i >> 1) & 1) * s, f64::from((i >> 2) & 1) * s)).collect()
+}
+
+/// The paper extents (width, height) of points seen through a frame.
+fn extents(frame: &ViewFrame, points: &[Vec3]) -> Vec2 {
+ let paper: Vec<Vec2> = points.iter().map(|p| frame.to_paper(*p)).collect();
+ let span = |f: fn(&Vec2) -> f64| {
+ let values = paper.iter().map(f);
+ values.clone().fold(f64::NEG_INFINITY, f64::max) - values.fold(f64::INFINITY, f64::min)
+ };
+ Vec2::new(span(|p| p.x), span(|p| p.y))
+}
+
+fn full_size(view: NamedView) -> ViewFrame {
+ ViewFrame::new(view.basis(), Scale::new(1.0, 1.0).unwrap(), Vec2::ZERO, Vec2::ZERO).unwrap()
+}
+
+/// Every named view is an exact, right-handed, orthonormal basis whose normal points back at the
+/// viewer: the principal views from where their names say, the isometric views from their
+/// upper corners with paper x horizontal.
+#[test]
+fn each_named_view_looks_from_where_its_name_says() {
+ let viewer = [
+ (NamedView::Front, Vec3::new(0.0, -1.0, 0.0)),
+ (NamedView::Back, Vec3::Y),
+ (NamedView::Top, Vec3::Z),
+ (NamedView::Bottom, Vec3::new(0.0, 0.0, -1.0)),
+ (NamedView::Left, Vec3::new(-1.0, 0.0, 0.0)),
+ (NamedView::Right, Vec3::X),
+ (NamedView::IsoFrontRight, Vec3::new(1.0, -1.0, 1.0) * (1.0 / 3f64.sqrt())),
+ (NamedView::IsoFrontLeft, Vec3::new(-1.0, -1.0, 1.0) * (1.0 / 3f64.sqrt())),
+ (NamedView::IsoBackRight, Vec3::new(1.0, 1.0, 1.0) * (1.0 / 3f64.sqrt())),
+ (NamedView::IsoBackLeft, Vec3::new(-1.0, 1.0, 1.0) * (1.0 / 3f64.sqrt())),
+ ];
+ assert_eq!(viewer.len(), NamedView::ALL.len());
+ for (view, toward_viewer) in viewer {
+ let b = view.basis();
+ validate_plane(&b).unwrap();
+ assert!(close(b.normal(), toward_viewer), "{view:?}: normal {:?}", b.normal());
+ assert_eq!(b.origin, Vec3::ZERO);
+ assert!(b.y.z >= 0.0, "{view:?}: paper y never points down");
+ if matches!(view, NamedView::IsoFrontRight | NamedView::IsoFrontLeft | NamedView::IsoBackRight | NamedView::IsoBackLeft) {
+ assert!(b.x.z.abs() < EPS, "{view:?}: paper x is horizontal");
+ }
+ }
+ // The principal views' axes are exact, no rounding from a camera, and each lies on its paper
+ // as the front view folded about the edge they share: the top and bottom views keep x along
+ // +X, the back and side views keep y along +Z.
+ let minus = |v: Vec3| Vec3::ZERO - v;
+ let principal = [
+ (NamedView::Front, Vec3::X, Vec3::Z),
+ (NamedView::Back, minus(Vec3::X), Vec3::Z),
+ (NamedView::Top, Vec3::X, Vec3::Y),
+ (NamedView::Bottom, Vec3::X, minus(Vec3::Y)),
+ (NamedView::Left, minus(Vec3::Y), Vec3::Z),
+ (NamedView::Right, Vec3::Y, Vec3::Z),
+ ];
+ for (view, x, y) in principal {
+ assert_eq!((view.basis().x, view.basis().y), (x, y), "{view:?}");
+ }
+ // The sketch plane XZ is not the front view: its y is -Z, a front view's is +Z.
+ assert_eq!(Plane::XZ.y, Vec3::new(0.0, 0.0, -1.0));
+ assert_eq!(NamedView::Front.basis().y, Vec3::Z);
+ // No axis has a -0, so a view writes out as `[-1.0, 0.0, 0.0]`, never `[-1.0, -0.0, -0.0]`.
+ let negative_zero = |v: Vec3| [v.x, v.y, v.z].iter().any(|c| *c == 0.0 && c.is_sign_negative());
+ assert!(NamedView::ALL.iter().all(|v| !negative_zero(v.basis().x) && !negative_zero(v.basis().y)));
+}
+
+/// A view from a direction and an up gives the named views' bases (the principal ones exactly),
+/// keeps paper y in the plane of the up, and refuses a direction or up it can't make a view from.
+#[test]
+fn a_view_from_a_direction_and_up_matches_the_named_views() {
+ for view in NamedView::ALL {
+ let named = view.basis();
+ // Looking down, up is +Y (the back at the top); looking up, -Y (the front at the top).
+ let up = match view {
+ NamedView::Top => Vec3::Y,
+ NamedView::Bottom => Vec3::new(0.0, -1.0, 0.0),
+ _ => Vec3::Z,
+ };
+ let built = basis_looking(-named.normal(), up, Vec3::ZERO).unwrap();
+ assert!(close(built.x, named.x) && close(built.y, named.y), "{view:?}: {built:?}");
+ }
+ assert_eq!(basis_looking(Vec3::Y, Vec3::Z, Vec3::ZERO).unwrap(), NamedView::Front.basis(), "exact");
+ let leaning = basis_looking(Vec3::Y, Vec3::new(0.0, 0.1, 1.0), Vec3::new(1.0, 2.0, 3.0)).unwrap();
+ assert_eq!((leaning.x, leaning.y, leaning.origin), (Vec3::X, Vec3::Z, Vec3::new(1.0, 2.0, 3.0)));
+ let refused = [
+ (Vec3::ZERO, Vec3::Z, Vec3::ZERO),
+ (Vec3::new(f64::NAN, 1.0, 0.0), Vec3::Z, Vec3::ZERO),
+ (Vec3::Y, Vec3::ZERO, Vec3::ZERO),
+ (Vec3::Y, Vec3::new(0.0, f64::INFINITY, 0.0), Vec3::ZERO),
+ (Vec3::new(0.0, 0.0, -1.0), Vec3::Z, Vec3::ZERO),
+ (Vec3::Z, Vec3::new(1e-12, 0.0, 1.0), Vec3::ZERO),
+ (Vec3::Y, Vec3::Z, Vec3::new(f64::NAN, 0.0, 0.0)),
+ (Vec3::Y, Vec3::Z, Vec3::new(0.0, 1e13, 0.0)),
+ ];
+ for (direction, up, origin) in refused {
+ assert!(basis_looking(direction, up, origin).is_err(), "{direction:?} {up:?} {origin:?}");
+ }
+ // A bad origin is named as such, not as a bad basis.
+ for origin in [Vec3::new(f64::NAN, 0.0, 0.0), Vec3::new(0.0, 1e13, 0.0)] {
+ assert_eq!(basis_looking(Vec3::Y, Vec3::Z, origin), Err(Invalid("a view's origin is finite and within 1e12 mm of the world's")));
+ }
+ assert_eq!(serde_json::from_value::<NamedView>(serde_json::json!("iso")).unwrap(), NamedView::IsoFrontRight);
+ assert_eq!(serde_json::to_value(NamedView::IsoFrontRight).unwrap(), serde_json::json!("iso_front_right"));
+}
+
+/// An up just off the view direction still gives a square basis: its normal is the direction back
+/// at the viewer to rounding, where the cross product alone would tilt it by up to 9e-9 rad.
+#[test]
+fn an_up_just_off_the_direction_still_looks_along_it() {
+ for (direction, off) in [(Vec3::new(0.3, -0.7, 0.2), 1.0001e-9), (Vec3::new(1.0, 2.0, 3.0), 1.2e-9), (Vec3::Y, 1.0001e-9)] {
+ let d = direction.normalized().unwrap();
+ let aside = d.cross(Vec3::Z).normalized().unwrap();
+ let basis = basis_looking(direction, d + aside * off, Vec3::ZERO).unwrap();
+ let tilt = (basis.normal() + d).len();
+ assert!(tilt < 1e-14 && basis.x.dot(d).abs() < 1e-15, "{direction:?}: tilted {tilt:e}");
+ }
+}
+
+/// A 50 mm cube is a 50 mm square in every principal view at 1:1, and half that at 1:2. In an
+/// orthographic isometric view each edge reads 50·√(2/3), and the outline is 50·√2 wide.
+#[test]
+fn a_50_mm_cube_measures_as_the_views_say() {
+ for view in [NamedView::Front, NamedView::Back, NamedView::Top, NamedView::Bottom, NamedView::Left, NamedView::Right] {
+ let size = extents(&full_size(view), &cube());
+ assert!((size - Vec2::new(50.0, 50.0)).len() < EPS, "{view:?}: {size:?}");
+ let half = ViewFrame::new(view.basis(), "1:2".parse().unwrap(), Vec2::ZERO, Vec2::ZERO).unwrap();
+ assert!((extents(&half, &cube()) - Vec2::new(25.0, 25.0)).len() < EPS, "{view:?} at 1:2");
+ }
+ // Orthographic isometric: a vertical edge reads 50·√(2/3), and the outline is 50·√2 wide.
+ let iso = full_size(NamedView::IsoFrontRight);
+ let edge = iso.to_paper(Vec3::new(0.0, 0.0, 50.0)) - iso.to_paper(Vec3::ZERO);
+ assert!((edge.len() - 50.0 * (2.0f64 / 3.0).sqrt()).abs() < EPS, "{edge:?}");
+ assert!(edge.x.abs() < EPS, "a vertical edge stays vertical on paper");
+ let size = extents(&iso, &cube());
+ assert!((size.x - 50.0 * 2f64.sqrt()).abs() < EPS, "{size:?}");
+}
+
+/// The view's centre lands on its position, and the map scales about it.
+#[test]
+fn the_views_centre_lands_on_its_position() {
+ let front = NamedView::Front.basis();
+ let frame = ViewFrame::new(front, "2:1".parse().unwrap(), Vec2::new(50.0, 10.0), Vec2::new(210.0, 148.5)).unwrap();
+ assert!((frame.to_paper(Vec3::new(50.0, 0.0, 10.0)) - Vec2::new(210.0, 148.5)).len() < EPS);
+ assert!((frame.to_paper(Vec3::new(0.0, 7.0, 0.0)) - Vec2::new(110.0, 128.5)).len() < EPS, "depth doesn't move a point");
+ // W07's example: a 100 x 20 front view on A3 at 2:1, centred: boundary 110..310 x 128.5..168.5.
+ assert!((frame.to_paper(Vec3::new(100.0, 0.0, 20.0)) - Vec2::new(310.0, 168.5)).len() < EPS);
+ let boundary = frame.boundary(&Aabb2 { min: Vec2::ZERO, max: Vec2::new(100.0, 20.0) }).unwrap();
+ assert!(boundary.min.dist(Vec2::new(110.0, 128.5)) < EPS && boundary.max.dist(Vec2::new(310.0, 168.5)) < EPS, "{boundary:?}");
+ // A box that is inside out, or not finite on paper, has no boundary: never one that drops a
+ // corner. 1e308 is finite in the plane, but not at 2:1.
+ let box_of = |x0: f64, y0: f64, x1: f64, y1: f64| Aabb2 { min: Vec2::new(x0, y0), max: Vec2::new(x1, y1) };
+ let refused = [
+ Aabb2::EMPTY,
+ box_of(10.0, 0.0, 0.0, 10.0),
+ box_of(f64::NAN, 0.0, 10.0, 10.0),
+ box_of(0.0, 0.0, f64::INFINITY, 10.0),
+ box_of(0.0, 0.0, 1e308, 10.0),
+ ];
+ for model in refused {
+ assert_eq!(frame.boundary(&model), Err(Invalid("a view's box is not inside out and is finite on paper")), "{model:?}");
+ }
+ assert!(frame.boundary(&box_of(5.0, 5.0, 5.0, 5.0)).is_ok_and(|b| b.min == b.max), "a point's box is a point");
+ let line = Seg2::Line { a: Vec2::ZERO, b: Vec2::new(100.0, 20.0) };
+ assert_eq!(frame.seg_to_paper(&line), Seg2::Line { a: Vec2::new(110.0, 128.5), b: Vec2::new(310.0, 168.5) });
+ let bounded = CurveAccuracy::Bounded { max_deviation_mm: 0.01 };
+ assert_eq!(frame.accuracy_on_paper(bounded), CurveAccuracy::Bounded { max_deviation_mm: 0.02 });
+ assert_eq!(frame.accuracy_on_paper(CurveAccuracy::Analytic), CurveAccuracy::Analytic);
+}
+
+/// A scale is read and written as paper:model, kept as written, within 1:100000 to 1000:1.
+#[test]
+fn a_scale_reads_and_writes_as_paper_to_model() {
+ for (text, factor) in [("1:1", 1.0), ("1:2", 0.5), ("2:1", 2.0), ("1:2.5", 0.4), ("1:100000", 1e-5), ("1000:1", 1000.0), ("3:7", 3.0 / 7.0)] {
+ let s: Scale = text.parse().unwrap();
+ assert_eq!((s.to_string(), s.factor()), (text.to_string(), factor), "{text}");
+ assert_eq!(serde_json::to_value(s).unwrap(), serde_json::json!(text));
+ assert_eq!(serde_json::from_value::<Scale>(serde_json::json!(text)).unwrap(), s);
+ }
+ let not_scales = [
+ "", "1", "1:", ":2", "1:2:3", "0:1", "1:0", "-1:2", "1:-2", "1:100001", "1001:1", "1/2", " 1:2", "1:2 ", "1e3:1", "NaN:1", "inf:1", "1..5:1",
+ "1:2.", "١:٢",
+ ];
+ for text in not_scales {
+ assert!(text.parse::<Scale>().is_err(), "{text:?}");
+ }
+ assert!(serde_json::from_value::<Scale>(serde_json::json!(0.5)).is_err(), "a bare number is not a scale");
+ for (paper, model) in [(0.0, 1.0), (1.0, 0.0), (f64::NAN, 1.0), (1.0, f64::INFINITY), (1.0, 1e300), (1e-300, 1.0)] {
+ assert!(Scale::new(paper, model).is_err(), "{paper}:{model}");
+ }
+ // Each side is capped too, or 1e300:1e300 (1:1) would write 603 characters.
+ for (paper, model) in [(1e300, 1e300), (1e-300, 1e-300), (1.000001e6, 1.000001e6), (0.9e-6, 0.9e-6)] {
+ assert!(Scale::new(paper, model).is_err(), "{paper}:{model}");
+ }
+ assert!("1000001:1000001".parse::<Scale>().is_err() && "0.0000009:0.0000009".parse::<Scale>().is_err());
+ // The longest a scale writes: its widest sides, about 50 characters.
+ for (paper, model) in [(1e6, 1e6), (MIN_PART, MIN_PART), (1.2345678901234567e-6, 1.2345678901234567e-6), (999999.9999999999, 999999.9999999999)] {
+ let text = Scale::new(paper, model).unwrap().to_string();
+ assert!(text.len() <= 50, "{text}");
+ assert_eq!(text.parse::<Scale>().unwrap(), Scale::new(paper, model).unwrap(), "{text}");
+ }
+}
+
+/// The fitted scale is the largest ISO 5455 preset at which the view fits: W07's 100 x 20 front
+/// view fits an A3 drawing area at 2:1 (5:1 would be 500 mm wide), exactly fitting counts, and a
+/// view too large for every preset gets none.
+#[test]
+fn the_fitted_scale_is_the_largest_preset_that_fits() {
+ let a3 = Vec2::new(400.0, 277.0);
+ assert_eq!(Scale::fit(Vec2::new(100.0, 20.0), a3).map(|s| s.to_string()), Some("2:1".into()));
+ assert_eq!(Scale::fit(Vec2::new(400.0, 10.0), a3).map(|s| s.to_string()), Some("1:1".into()), "an exact fit counts");
+ assert_eq!(Scale::fit(Vec2::new(400.1, 10.0), a3).map(|s| s.to_string()), Some("1:2".into()));
+ assert_eq!(Scale::fit(Vec2::new(1.0, 1.0), a3).map(|s| s.to_string()), Some("50:1".into()));
+ assert_eq!(Scale::fit(Vec2::new(4e6, 1.0), a3).map(|s| s.to_string()), Some("1:10000".into()), "ISO 5455's smallest");
+ assert_eq!(Scale::fit(Vec2::new(5e6, 1.0), a3), None);
+ // An exact fit at a reduction counts though its factor rounds: 1675.75 * 0.2 is 335.15000000000003.
+ let room = Vec2::new(335.15, 1000.0);
+ assert_eq!(Scale::fit(Vec2::new(1675.75, 1.0), room).map(|s| s.to_string()), Some("1:5".into()));
+ // The presets run largest first, each a 1, 2 or 5 step.
+ assert!(PRESETS.windows(2).all(|w| w[0].factor() > w[1].factor()));
+ // A size of 0 sets no limit that way: a line fits by its length, a point at the largest preset.
+ assert_eq!(Scale::fit(Vec2::new(0.0, 20.0), a3).map(|s| s.to_string()), Some("10:1".into()));
+ assert_eq!(Scale::fit(Vec2::ZERO, a3).map(|s| s.to_string()), Some("50:1".into()));
+ // A size or room that is negative or not finite fits nothing.
+ for (size, room) in [
+ (Vec2::new(-1.0, 1.0), a3),
+ (Vec2::new(1.0, -0.0001), a3),
+ (Vec2::new(f64::NAN, 1.0), a3),
+ (Vec2::new(1.0, f64::INFINITY), a3),
+ (Vec2::new(1.0, 1.0), Vec2::new(-400.0, 277.0)),
+ (Vec2::new(1.0, 1.0), Vec2::new(f64::INFINITY, 277.0)),
+ (Vec2::new(1.0, 1.0), Vec2::new(400.0, f64::NAN)),
+ ] {
+ assert_eq!(Scale::fit(size, room), None, "{size:?} in {room:?}");
+ }
+}
+
+/// What a frame refuses: a basis that isn't orthonormal or finite, a centre that isn't finite, and
+/// a position past the paper's limit.
+#[test]
+fn a_frame_refuses_hostile_input() {
+ let one = Scale::new(1.0, 1.0).unwrap();
+ let front = NamedView::Front.basis();
+ let bases = [
+ Plane { x: Vec3::new(2.0, 0.0, 0.0), ..front },
+ Plane { x: Vec3::Z, ..front },
+ Plane { origin: Vec3::new(f64::NAN, 0.0, 0.0), ..front },
+ Plane { y: Vec3::new(0.0, 0.0, f64::INFINITY), ..front },
+ ];
+ for basis in bases {
+ assert!(ViewFrame::new(basis, one, Vec2::ZERO, Vec2::ZERO).is_err(), "{basis:?}");
+ }
+ for centre in [Vec2::new(f64::NAN, 0.0), Vec2::new(0.0, f64::INFINITY), Vec2::new(1e13, 0.0)] {
+ assert!(ViewFrame::new(front, one, centre, Vec2::ZERO).is_err(), "{centre:?}");
+ }
+ for position in [Vec2::new(5000.001, 0.0), Vec2::new(0.0, -5000.001), Vec2::new(f64::NAN, 0.0)] {
+ assert!(ViewFrame::new(front, one, Vec2::ZERO, position).is_err(), "{position:?}");
+ }
+ assert!(ViewFrame::new(front, one, Vec2::ZERO, Vec2::new(5000.0, -5000.0)).is_ok());
+}
diff --git a/crates/geom/src/hlr/curve.rs b/crates/geom/src/hlr/curve.rs
new file mode 100644
index 0000000000..2da8e2e8fd
--- /dev/null
+++ b/crates/geom/src/hlr/curve.rs
@@ -0,0 +1,371 @@
+//! Evaluation of portable B-rep curves: lines, circle and ellipse arcs, polynomial and rational
+//! splines (fitted intersection records are ordinary splines with a stated fitting tolerance).
+
+use super::HlrError;
+use crate::Vec3;
+use crate::brep::{Curve, Frame};
+use crate::section::CurveAccuracy;
+
+#[derive(Clone, Debug)]
+pub(crate) enum C3 {
+ Line {
+ a: Vec3,
+ b: Vec3,
+ },
+ /// origin + x*rx*cos(t) + y*ry*sin(t), t in `range`.
+ Arc {
+ o: Vec3,
+ x: Vec3,
+ y: Vec3,
+ r: [f64; 2],
+ range: [f64; 2],
+ },
+ /// Homogeneous control points `[x*w, y*w, z*w, w]` (w = 1 for polynomial splines), and the
+ /// same curve as Bézier pieces (each piece's parameter span and control points; empty when
+ /// it could not be split).
+ Spline {
+ degree: usize,
+ knots: Vec<f64>,
+ points: Vec<[f64; 4]>,
+ pieces: Vec<([f64; 2], Vec<[f64; 4]>)>,
+ },
+ Polyline(Vec<Vec3>),
+}
+
+pub(crate) fn v3(p: [f64; 3]) -> Vec3 {
+ Vec3::new(p[0], p[1], p[2])
+}
+
+pub(crate) fn frame_axes(f: &Frame) -> (Vec3, Vec3, Vec3) {
+ let (x, y) = (v3(f.x_axis), v3(f.y_axis));
+ (v3(f.origin), x, y)
+}
+
+impl C3 {
+ pub fn new(c: &Curve) -> Result<(C3, CurveAccuracy), HlrError> {
+ Ok(match c {
+ Curve::Line { start, end } => (C3::Line { a: v3(*start), b: v3(*end) }, CurveAccuracy::Analytic),
+ Curve::CircleArc { frame, radius, angle } => {
+ let (o, x, y) = frame_axes(frame);
+ (C3::Arc { o, x, y, r: [*radius, *radius], range: *angle }, CurveAccuracy::Analytic)
+ }
+ Curve::EllipseArc { frame, radii, angle } => {
+ let (o, x, y) = frame_axes(frame);
+ (C3::Arc { o, x, y, r: *radii, range: *angle }, CurveAccuracy::Analytic)
+ }
+ Curve::Polyline { points } => (C3::Polyline(points.iter().copied().map(v3).collect()), CurveAccuracy::Analytic),
+ Curve::Spline { knots, points } => (spline(knots, points.iter().map(|p| [p[0], p[1], p[2], 1.]).collect())?, CurveAccuracy::Analytic),
+ Curve::RationalSpline { knots, homogeneous } => (spline(knots, homogeneous.clone())?, CurveAccuracy::Analytic),
+ Curve::Intersection { knots, points, fitting_tolerance, .. } => (
+ spline(knots, points.iter().map(|p| [p[0], p[1], p[2], 1.]).collect())?,
+ CurveAccuracy::Bounded { max_deviation_mm: *fitting_tolerance },
+ ),
+ // Procedural: the curve is traced on demand from its leader, which carries no bound.
+ Curve::SurfaceIntersection { .. } => return Err(HlrError::Unsupported("surface intersection curve")),
+ })
+ }
+
+ pub fn domain(&self) -> [f64; 2] {
+ match self {
+ C3::Line { .. } => [0., 1.],
+ C3::Arc { range, .. } => *range,
+ C3::Spline { degree, knots, points, .. } => [knots.get(*degree).copied().unwrap_or(0.), knots.get(points.len()).copied().unwrap_or(1.)],
+ C3::Polyline(p) => [0., p.len().saturating_sub(1) as f64],
+ }
+ }
+
+ pub fn at(&self, t: f64) -> Vec3 {
+ match self {
+ C3::Line { a, b } => *a + (*b - *a) * t,
+ C3::Arc { o, x, y, r, .. } => *o + *x * (r[0] * t.cos()) + *y * (r[1] * t.sin()),
+ C3::Spline { degree, knots, points, .. } => de_boor(*degree, knots, points, t),
+ C3::Polyline(p) => {
+ let n = p.len();
+ if n == 0 {
+ return Vec3::ZERO;
+ }
+ let t = t.clamp(0., (n - 1) as f64);
+ let i = (t.floor() as usize).min(n.saturating_sub(2));
+ match (p.get(i), p.get(i + 1)) {
+ (Some(a), Some(b)) => a.lerp(*b, t - i as f64),
+ (Some(a), None) => *a,
+ _ => Vec3::ZERO,
+ }
+ }
+ }
+ }
+
+ /// First derivative by a central difference scaled to the domain.
+ pub fn d1(&self, t: f64) -> Vec3 {
+ match self {
+ C3::Line { a, b } => *b - *a,
+ C3::Arc { x, y, r, .. } => *x * (-r[0] * t.sin()) + *y * (r[1] * t.cos()),
+ _ => {
+ let [t0, t1] = self.domain();
+ let h = (t1 - t0) * 1e-6;
+ let (a, b) = ((t - h).max(t0), (t + h).min(t1));
+ if b - a <= 0. { Vec3::ZERO } else { (self.at(b) - self.at(a)) / (b - a) }
+ }
+ }
+ }
+
+ /// Parameters that split the curve into pieces each turning at most `max_turn` radians or
+ /// spanning at most a quarter of the domain, plus all interior knots.
+ pub fn breaks(&self) -> Vec<f64> {
+ let [t0, t1] = self.domain();
+ let mut out = vec![t0, t1];
+ match self {
+ C3::Spline { knots, .. } => out.extend(knots.iter().copied().filter(|k| *k > t0 && *k < t1)),
+ C3::Polyline(p) => out.extend((1..p.len().saturating_sub(1)).map(|i| i as f64)),
+ C3::Arc { .. } => {
+ let n = ((t1 - t0) / (std::f64::consts::PI / 8.)).ceil().max(1.) as usize;
+ out.extend((1..n).map(|i| t0 + (t1 - t0) * i as f64 / n as f64));
+ }
+ C3::Line { .. } => {}
+ }
+ out.sort_by(f64::total_cmp);
+ // Only equal knots merge: a span narrower than rounding can still carry a whole arc.
+ out.dedup();
+ out
+ }
+}
+
+fn spline(knots: &[f64], points: Vec<[f64; 4]>) -> Result<C3, HlrError> {
+ let degree = knots.len().checked_sub(points.len() + 1).ok_or(HlrError::Unsupported("spline knot count"))?;
+ if degree == 0 || degree > 16 || points.is_empty() {
+ return Err(HlrError::Unsupported("spline degree"));
+ }
+ let pieces = bezier_pieces(degree, knots, &points);
+ Ok(C3::Spline { degree, knots: knots.to_vec(), points, pieces })
+}
+
+/// A spline split into Bézier pieces: clamped, then every inner knot raised to the degree
+/// (NURBS Book §5.2); empty when that fails.
+fn bezier_pieces(p: usize, knots: &[f64], points: &[[f64; 4]]) -> Vec<([f64; 2], Vec<[f64; 4]>)> {
+ use crate::bspline::{HPoint, clamp_row, insert_knot};
+ let row: Vec<HPoint> = points.iter().map(|h| HPoint { x: h[0], y: h[1], z: h[2], w: h[3] }).collect();
+ let Ok((mut k, mut c)) = clamp_row(p, knots, &row) else { return Vec::new() };
+ let (Some(&lo), Some(&hi)) = (k.get(p), k.get(c.len())) else { return Vec::new() };
+ let mut inner: Vec<f64> = k.iter().copied().filter(|x| *x > lo && *x < hi).collect();
+ inner.dedup();
+ for u in &inner {
+ let mut guard = 0;
+ while k.iter().filter(|x| *x == u).count() < p {
+ guard += 1;
+ let Ok((nk, nc)) = insert_knot(p, &k, &c, *u) else { return Vec::new() };
+ if guard > p + 1 {
+ return Vec::new();
+ }
+ (k, c) = (nk, nc);
+ }
+ }
+ let breaks: Vec<f64> = std::iter::once(lo).chain(inner).chain(std::iter::once(hi)).collect();
+ let mut out = Vec::with_capacity(breaks.len());
+ for (j, w) in breaks.windows(2).enumerate() {
+ let (Some(&s0), Some(&s1)) = (w.first(), w.get(1)) else { return Vec::new() };
+ let Some(ctrl) = c.get(j * p..=j * p + p) else { return Vec::new() };
+ out.push(([s0, s1], ctrl.iter().map(|h| [h.x, h.y, h.z, h.w]).collect()));
+ }
+ out
+}
+
+/// The Bernstein coefficients of the product of two polynomials given by theirs.
+fn bernstein_product(a: &[f64], b: &[f64]) -> Vec<f64> {
+ use crate::bspline::binomial;
+ let (m, n) = (a.len().saturating_sub(1), b.len().saturating_sub(1));
+ (0..=m + n)
+ .map(|k| {
+ let terms = (k.saturating_sub(n)..=k.min(m))
+ .map(|i| binomial(m, i) * binomial(n, k - i) * a.get(i).copied().unwrap_or(0.) * b.get(k - i).copied().unwrap_or(0.));
+ terms.sum::<f64>() / binomial(m + n, k)
+ })
+ .collect()
+}
+
+/// The sign a polynomial in Bernstein form keeps over its interval: +1, -1, 0 when it is zero
+/// (to rounding) all along, `None` when that cannot be certified. All coefficients of one sign
+/// mean the polynomial has it (their hull holds its graph); otherwise the interval is halved.
+fn definite_sign(c: &[f64], depth: u32) -> Option<f64> {
+ let scale = c.iter().fold(0f64, |m, x| m.max(x.abs()));
+ let eps = 1e-12 * scale;
+ if c.iter().all(|x| x.abs() <= eps) {
+ return Some(0.);
+ }
+ if c.iter().all(|x| *x >= -eps) {
+ return Some(1.);
+ }
+ if c.iter().all(|x| *x <= eps) {
+ return Some(-1.);
+ }
+ if depth >= 16 {
+ return None;
+ }
+ // de Casteljau at the middle.
+ let (mut left, mut right, mut pts) = (Vec::with_capacity(c.len()), Vec::with_capacity(c.len()), c.to_vec());
+ while let (Some(&f), Some(&l)) = (pts.first(), pts.last()) {
+ left.push(f);
+ right.push(l);
+ pts = pts.windows(2).map(|w| 0.5 * (w.first().copied().unwrap_or(0.) + w.get(1).copied().unwrap_or(0.))).collect();
+ }
+ right.reverse();
+ match (definite_sign(&left, depth + 1)?, definite_sign(&right, depth + 1)?) {
+ (a, b) if a == b || b == 0. => Some(a),
+ (0., b) => Some(b),
+ _ => None,
+ }
+}
+
+impl C3 {
+ /// The way a spline's part `r` turns about the centre `o` in the plane of `u` and `v`:
+ /// +1 or -1 when its angular speed keeps that sign all along (certified on each Bézier piece
+ /// from the Bernstein coefficients of `X Y' - Y X'`, which has the speed's sign as the
+ /// weights are positive), 0 when it does not turn, `None` when it turns back or this cannot
+ /// be certified.
+ pub fn turn_sign(&self, r: [f64; 2], o: Vec3, u: Vec3, v: Vec3) -> Option<f64> {
+ use crate::bspline::{HPoint, bezier_segment};
+ let C3::Spline { pieces, .. } = self else { return None };
+ let mut sign = 0f64;
+ for (span, ctrl) in pieces {
+ let (a, b) = (r[0].max(span[0]), r[1].min(span[1]));
+ let len = span[1] - span[0];
+ if !(b > a && len > 0.) {
+ continue;
+ }
+ let (fa, fb) = (((a - span[0]) / len).clamp(0., 1.), ((b - span[0]) / len).clamp(0., 1.));
+ if !(fb > fa) {
+ continue;
+ }
+ let h: Vec<HPoint> = ctrl.iter().map(|q| HPoint { x: q[0], y: q[1], z: q[2], w: q[3] }).collect();
+ let seg = bezier_segment(&h, fa, fb).ok()?;
+ if seg.iter().any(|q| !(q.w > 0.)) {
+ return None;
+ }
+ let rel = |q: &HPoint| Vec3::new(q.x, q.y, q.z) - o * q.w;
+ let x: Vec<f64> = seg.iter().map(|q| rel(q).dot(u)).collect();
+ let y: Vec<f64> = seg.iter().map(|q| rel(q).dot(v)).collect();
+ let p = x.len().saturating_sub(1);
+ if p == 0 {
+ return None;
+ }
+ let d = |c: &[f64]| {
+ c.windows(2).map(|w| p as f64 * (w.get(1).copied().unwrap_or(0.) - w.first().copied().unwrap_or(0.))).collect::<Vec<f64>>()
+ };
+ let n: Vec<f64> = bernstein_product(&x, &d(&y)).iter().zip(bernstein_product(&y, &d(&x))).map(|(a, b)| a - b).collect();
+ let s = definite_sign(&n, 0)?;
+ if s != 0. {
+ if sign != 0. && s != sign {
+ return None;
+ }
+ sign = s;
+ }
+ }
+ Some(sign)
+ }
+
+ /// Points whose hull holds the spline's part `r`: the projected control points of its
+ /// Bézier pieces cut to `r` (de Casteljau). They close in on the curve as `r` shrinks.
+ /// `None` for other curves, or when a weight is not positive.
+ pub fn hull(&self, r: [f64; 2]) -> Option<Vec<Vec3>> {
+ use crate::bspline::{HPoint, bezier_segment};
+ let C3::Spline { pieces, .. } = self else { return None };
+ let mut out = Vec::new();
+ for (span, ctrl) in pieces {
+ let (a, b) = (r[0].max(span[0]), r[1].min(span[1]));
+ let len = span[1] - span[0];
+ if !(b > a && len > 0.) {
+ continue;
+ }
+ let (fa, fb) = (((a - span[0]) / len).clamp(0., 1.), ((b - span[0]) / len).clamp(0., 1.));
+ if !(fb > fa) {
+ continue;
+ }
+ let h: Vec<HPoint> = ctrl.iter().map(|q| HPoint { x: q[0], y: q[1], z: q[2], w: q[3] }).collect();
+ for q in bezier_segment(&h, fa, fb).ok()? {
+ if !(q.w > 0.) {
+ return None;
+ }
+ out.push(q.project()?);
+ }
+ }
+ (!out.is_empty()).then_some(out)
+ }
+}
+
+/// De Boor evaluation of a (rational) B-spline at `t`, clamped to the active domain.
+pub(crate) fn de_boor(p: usize, knots: &[f64], ctrl: &[[f64; 4]], t: f64) -> Vec3 {
+ let n = ctrl.len();
+ let (Some(&lo), Some(&hi)) = (knots.get(p), knots.get(n)) else { return Vec3::ZERO };
+ let t = t.clamp(lo, hi);
+ // Span k with knots[k] <= t < knots[k+1], last nonempty span at the end.
+ let mut k = p;
+ while k + 1 < n && knots.get(k + 1).is_some_and(|u| *u <= t) {
+ k += 1;
+ }
+ let mut d: Vec<[f64; 4]> = (0..=p).map(|j| ctrl.get(j + k - p).copied().unwrap_or([0.; 4])).collect();
+ for r in 1..=p {
+ for j in (r..=p).rev() {
+ let (a, b) = (knots.get(j + k - p).copied().unwrap_or(0.), knots.get(j + 1 + k - r).copied().unwrap_or(0.));
+ let alpha = if b - a == 0. { 0. } else { (t - a) / (b - a) };
+ let (prev, cur) = (d.get(j - 1).copied().unwrap_or([0.; 4]), d.get(j).copied().unwrap_or([0.; 4]));
+ if let Some(slot) = d.get_mut(j) {
+ for c in 0..4 {
+ slot[c] = (1. - alpha) * prev[c] + alpha * cur[c];
+ }
+ }
+ }
+ }
+ let h = d.get(p).copied().unwrap_or([0.; 4]);
+ if h[3] == 0. { Vec3::ZERO } else { Vec3::new(h[0] / h[3], h[1] / h[3], h[2] / h[3]) }
+}
+
+/// The circle a curve lies on, if it is one: centre, unit normal, radius. Checked at many
+/// parameters against `tol` (relative to the radius), so rational circle splines are recognised.
+pub(crate) fn as_circle(c: &C3, tol: f64) -> Option<(Vec3, Vec3, f64)> {
+ match c {
+ C3::Arc { o, x, y, r, .. } if (r[0] - r[1]).abs() <= tol * r[0] => Some((*o, x.cross(*y).normalized()?, r[0])),
+ C3::Spline { degree, points, .. } => {
+ let [t0, t1] = c.domain();
+ let at = |f: f64| c.at(t0 + (t1 - t0) * f);
+ let (a, b, m) = (at(0.), at(1.), at(0.5));
+ // Circumcentre of a, m and a third point (b may equal a for a full circle).
+ let third = if a.dist(b) < 1e-9 * (1. + a.len()) { at(0.25) } else { b };
+ let (u, v) = (m - a, third - a);
+ let n = u.cross(v);
+ let n2 = n.len2();
+ if n2 <= 1e-24 {
+ return None;
+ }
+ let centre = a + (v * u.len2() - u * v.len2()).cross(n) * (1. / (2. * n2));
+ let normal = n.normalized()?;
+ let r = centre.dist(a);
+ // On one knot span of a (rational) spline of degree p, f = w^2 (|P - c|^2 - r^2) is
+ // a polynomial of degree 2p. At 2p + 3 Chebyshev points of the span it is at most
+ // w_max^2 2 r d (d the largest distance from the circle there), so everywhere at most
+ // 4 times that (their Lebesgue constant is below 4), and as w >= w_min the distance
+ // anywhere is at most 4 (w_max / w_min)^2 d: weights near zero cannot hide a swerve.
+ let weights = points.iter().map(|h| h[3]);
+ let (w_min, w_max) = weights.fold((f64::MAX, f64::MIN), |(lo, hi), w| (lo.min(w), hi.max(w)));
+ if !(w_min > 0. && w_max.is_finite()) {
+ return None;
+ }
+ let off = |p: Vec3| (p.dist(centre) - r).abs().max((p - centre).dot(normal).abs());
+ let n = (2 * degree + 3).max(9);
+ let mut d = 0f64;
+ for w in c.breaks().windows(2) {
+ let (Some(&s0), Some(&s1)) = (w.first(), w.get(1)) else { continue };
+ let (mid, half) = (0.5 * (s0 + s1), 0.5 * (s1 - s0));
+ d = d.max(off(c.at(s0))).max(off(c.at(s1)));
+ for k in 0..n {
+ d = d.max(off(c.at(mid + half * (std::f64::consts::PI * (2 * k + 1) as f64 / (2 * n) as f64).cos())));
+ }
+ }
+ // Relative to the curve's own size when that is smaller than the radius: a nearly
+ // straight curve fits a huge circle, whose radius says nothing about the error.
+ let pts: Vec<Vec3> = points.iter().filter(|h| h[3] != 0.).map(|h| Vec3::new(h[0] / h[3], h[1] / h[3], h[2] / h[3])).collect();
+ let size = pts.iter().skip(1).fold(pts.first().map(|p| (*p, *p)), |acc, p| acc.map(|(lo, hi)| (lo.min(*p), hi.max(*p))));
+ let size = size.map_or(r, |(lo, hi)| (hi - lo).len());
+ (4. * (w_max / w_min).powi(2) * d <= tol * r.min(size)).then_some((centre, normal, r))
+ }
+ _ => None,
+ }
+}
diff --git a/crates/geom/src/hlr/mod.rs b/crates/geom/src/hlr/mod.rs
new file mode 100644
index 0000000000..8023c914fe
--- /dev/null
+++ b/crates/geom/src/hlr/mod.rs
@@ -0,0 +1,1915 @@
+//! Exact orthographic hidden lines for placed portable B-rep bodies (Drawing W06a, #2455;
+//! plan #860). Edges and face silhouettes are projected from their exact curves, split where
+//! their projections cross, and each piece is classified by rays toward the viewer against the
+//! trimmed faces. Every piece is visible, hidden or explicitly uncertain; nothing is guessed.
+//!
+//! Supported: planes, and cylinders, cones, spheres and tori whether stored as analytic records,
+//! revolutions of lines and circles or spline patches (recognised to 1e-9 relative and then
+//! trimmed and intersected in their own chart). Other spline and revolution faces are freeform:
+//! unless [`Options::freeform`] is set they are listed in [`Drawing::unsupported`], their
+//! silhouettes are not drawn and anything they could hide is reported uncertain.
+//!
+//! Work is done in a frame centred on the scene, so results do not drift for parts far from the
+//! origin. Output curves are `Seg2` pieces in screen millimetres with the accuracy vocabulary of
+//! [`crate::section`]. See `docs/drawing-hlr.md` for the contract and its measured limits.
+
+pub(crate) mod curve;
+mod silhouette;
+pub(crate) mod surface;
+mod trim;
+
+use serde::Serialize;
+
+use crate::brep::Brep;
+use crate::section::CurveAccuracy;
+use crate::{Seg2, Vec2, Vec3};
+use curve::{C3, as_circle};
+use surface::{Analytic, Hit, S3};
+use trim::Trim;
+
+#[derive(Debug, thiserror::Error)]
+pub enum HlrError {
+ #[error("not supported yet: {0}")]
+ Unsupported(&'static str),
+ #[error("hidden lines: {0} budget exceeded")]
+ Budget(&'static str),
+ #[error("hidden lines: cancelled")]
+ Cancelled,
+ #[error("hidden lines: invalid {0}")]
+ Invalid(&'static str),
+}
+
+/// An orthographic view: `d` is the direction of sight; screen coordinates are `(p.x, p.y)`.
+#[derive(Clone, Copy, Debug)]
+pub struct View {
+ pub x: Vec3,
+ pub y: Vec3,
+ pub d: Vec3,
+}
+
+impl View {
+ pub fn new(d: Vec3, up: Vec3) -> Result<View, HlrError> {
+ let d = d.normalized().ok_or(HlrError::Invalid("view direction"))?;
+ let x = d.cross(up).normalized().ok_or(HlrError::Invalid("view up direction"))?;
+ Ok(View { x, y: x.cross(d), d })
+ }
+ pub fn screen(&self, p: Vec3) -> [f64; 2] {
+ [p.dot(self.x), p.dot(self.y)]
+ }
+}
+
+/// One placed body: `world = rotation * local + translation`, rotation columns given.
+#[derive(Clone, Copy, Debug)]
+pub struct Placement {
+ pub body: usize,
+ pub rotation: [Vec3; 3],
+ pub translation: Vec3,
+}
+
+impl Placement {
+ fn apply(&self, p: Vec3) -> Vec3 {
+ let [a, b, c] = self.rotation;
+ a * p.x + b * p.y + c * p.z + self.translation
+ }
+ fn local_dir(&self, v: Vec3) -> Vec3 {
+ let [a, b, c] = self.rotation;
+ Vec3::new(a.dot(v), b.dot(v), c.dot(v))
+ }
+ fn local(&self, p: Vec3) -> Vec3 {
+ self.local_dir(p - self.translation)
+ }
+ fn rigid(&self) -> bool {
+ let [a, b, c] = self.rotation;
+ [a, b, c].iter().all(|v| v.is_finite() && (v.len() - 1.).abs() < 1e-9)
+ && a.dot(b).abs() < 1e-9
+ && a.dot(c).abs() < 1e-9
+ && b.dot(c).abs() < 1e-9
+ && (a.cross(b).dot(c) - 1.).abs() < 1e-9
+ && self.translation.is_finite()
+ }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub enum EdgeKind {
+ Sharp,
+ /// Between two faces that meet tangentially (or lie on one surface).
+ Tangent,
+ /// Used twice by one face, or between two faces of one analytic surface (a patch boundary).
+ Seam,
+}
+
+struct EdgeData {
+ curve: C3,
+ acc: CurveAccuracy,
+ faces: Vec<usize>,
+ kind: EdgeKind,
+}
+
+struct FaceData {
+ surface: S3,
+ analytic: Analytic,
+ /// Faces of this body on the same quadric or torus (patches of one surface), itself included.
+ group: Vec<usize>,
+ trim: Trim,
+ lo: Vec3,
+ hi: Vec3,
+ /// Neither a plane nor a recognised quadric or torus.
+ freeform: bool,
+}
+
+/// A body prepared once and shared by all of its placements.
+pub struct Prepared {
+ edges: Vec<EdgeData>,
+ faces: Vec<FaceData>,
+ /// The body's records are kept moved by `-offset` (to its own centre), so its coordinates
+ /// stay small wherever it was modelled; placements add it back.
+ offset: Vec3,
+ lo: Vec3,
+ hi: Vec3,
+ pub report: PrepareReport,
+}
+
+#[derive(Clone, Debug, Default, Serialize)]
+pub struct PrepareReport {
+ pub faces: usize,
+ pub edges: usize,
+ /// Face counts by recognised surface: plane, cylinder, cone, sphere, torus, other.
+ pub surfaces: std::collections::BTreeMap<String, usize>,
+ /// Edge counts by record kind and recognition, e.g. `rational_spline/circle`.
+ pub curves: std::collections::BTreeMap<String, usize>,
+ pub tangent_edges: usize,
+ pub seam_edges: usize,
+ /// Faces whose trim could not be classified, with the reason.
+ pub unsupported_trims: Vec<(usize, String)>,
+ /// Largest distance between a boundary curve and the chords used for trimming (mm).
+ pub max_trim_chord: f64,
+ /// Faces outside the supported subset (see [`Options::freeform`]).
+ pub freeform_faces: Vec<usize>,
+}
+
+/// Whether two recognised surfaces are the same quadric or torus (planes never: coplanar
+/// faces of a split are real edges in the record, and are drawn).
+fn same_analytic(a: &Analytic, b: &Analytic, tol: f64) -> bool {
+ let close = |x: Vec3, y: Vec3, scale: f64| x.dist(y) <= tol * (1. + scale);
+ let on_axis = |p: Vec3, q: Vec3, a: Vec3, scale: f64| (q - p).cross(a).len() <= tol * (1. + scale);
+ match (a, b) {
+ (Analytic::Cylinder { p, a, r }, Analytic::Cylinder { p: q, a: b, r: s }) => {
+ (r - s).abs() <= tol * r && a.cross(*b).len() <= tol && on_axis(*p, *q, *a, *r)
+ }
+ (Analytic::Cone { apex, a, half }, Analytic::Cone { apex: b_apex, a: b, half: h }) => {
+ // The axes by their angle, as for cylinders and tori (a dot product would compare
+ // its square).
+ (half - h).abs() <= tol && a.cross(*b).len() <= tol && a.dot(*b) > 0. && close(*apex, *b_apex, apex.len())
+ }
+ (Analytic::Sphere { c, r }, Analytic::Sphere { c: d, r: s }) => (r - s).abs() <= tol * r && close(*c, *d, *r),
+ (Analytic::Torus { c, a, major, minor }, Analytic::Torus { c: d, a: b, major: m, minor: n }) => {
+ (major - m).abs() <= tol * major && (minor - n).abs() <= tol * major && a.cross(*b).len() <= tol && close(*c, *d, *major)
+ }
+ _ => false,
+ }
+}
+
+fn analytic_name(a: &Analytic) -> &'static str {
+ match a {
+ Analytic::Plane => "plane",
+ Analytic::Cylinder { .. } => "cylinder",
+ Analytic::Cone { .. } => "cone",
+ Analytic::Sphere { .. } => "sphere",
+ Analytic::Torus { .. } => "torus",
+ Analytic::Other => "other",
+ }
+}
+
+pub fn prepare(b: &Brep, opts: &Options) -> Result<Prepared, HlrError> {
+ prepare_cancellable(b, opts, &|| false)
+}
+
+/// [`prepare`], polling `cancel` between edges, faces and surface comparisons; when it returns
+/// true the call ends with `HlrError::Cancelled`.
+pub fn prepare_cancellable(b: &Brep, opts: &Options, cancel: &dyn Fn() -> bool) -> Result<Prepared, HlrError> {
+ if !(1..=MAX_TRIM_SAMPLES).contains(&opts.trim_samples) {
+ return Err(HlrError::Invalid("trim samples"));
+ }
+ b.validate().map_err(|_| HlrError::Invalid("portable B-rep"))?;
+ // Work on the body moved to its own centre: rounding in ray and inversion formulas grows
+ // with the coordinates, and a part may be modelled far from the origin (W05a finding 7).
+ let offset = anchor(b);
+ let moved = shifted(b, offset);
+ let b = &moved;
+ let mut edges = Vec::new();
+ let mut faces = Vec::new();
+ let mut report = PrepareReport::default();
+ for shell in &b.shells {
+ let base_face = faces.len();
+ let mut curves = Vec::with_capacity(shell.edges.len());
+ for (ei, e) in shell.edges.iter().enumerate() {
+ if ei % 256 == 0 && cancel() {
+ return Err(HlrError::Cancelled);
+ }
+ let (c, acc) = C3::new(&e.curve)?;
+ let record = match &e.curve {
+ crate::brep::Curve::Line { .. } => "line",
+ crate::brep::Curve::CircleArc { .. } => "circle_arc",
+ crate::brep::Curve::EllipseArc { .. } => "ellipse_arc",
+ crate::brep::Curve::Polyline { .. } => "polyline",
+ crate::brep::Curve::Spline { .. } => "spline",
+ crate::brep::Curve::RationalSpline { .. } => "rational_spline",
+ crate::brep::Curve::Intersection { .. } => "intersection",
+ crate::brep::Curve::SurfaceIntersection { .. } => "surface_intersection",
+ };
+ let shape = if matches!(c, C3::Line { .. }) {
+ "line"
+ } else if as_circle(&c, 1e-9).is_some() {
+ "circle"
+ } else {
+ "other"
+ };
+ *report.curves.entry(format!("{record}/{shape}")).or_insert(0) += 1;
+ curves.push((c, acc));
+ }
+ let local_curves: Vec<C3> = curves.iter().map(|(c, _)| c.clone()).collect();
+ let mut users: Vec<Vec<usize>> = vec![Vec::new(); shell.edges.len()];
+ for (fi, f) in shell.faces.iter().enumerate() {
+ if cancel() {
+ return Err(HlrError::Cancelled);
+ }
+ let mut surface = S3::new(&f.surface)?;
+ // A flat spline patch is a plane: trimmed and intersected as one.
+ if let Some(plane) = surface.flat(1e-9) {
+ surface = plane;
+ }
+ let analytic = surface.analytic(1e-9);
+ // Trim and intersect recognised spline surfaces in their own analytic chart.
+ if matches!(surface, S3::Nurbs(_)) {
+ let axis = match analytic {
+ Analytic::Cylinder { p, a, .. } => Some((p, a)),
+ Analytic::Cone { apex, a, .. } => Some((apex, a)),
+ _ => None,
+ };
+ let mut h = [0., 0.];
+ if let Some((p, a)) = axis {
+ let along = f.loops.iter().flatten().filter_map(|u| local_curves.get(u.edge as usize)).flat_map(|c| {
+ let [t0, t1] = c.domain();
+ (0..=64).map(move |i| c.at(t0 + (t1 - t0) * i as f64 / 64.))
+ });
+ let (lo, hi) = along.fold((f64::MAX, f64::MIN), |(lo, hi), q| ((q - p).dot(a).min(lo), (q - p).dot(a).max(hi)));
+ // Generous: the chart only has to contain the face; the trim bounds it exactly.
+ let pad = 0.01 * (hi - lo).abs() + 1e-6;
+ h = [lo - pad, hi + pad];
+ }
+ let toward = match analytic {
+ Analytic::Sphere { c, .. } => {
+ let pts: Vec<Vec3> = f
+ .loops
+ .iter()
+ .flatten()
+ .filter_map(|u| local_curves.get(u.edge as usize))
+ .map(|c| c.at(0.5 * (c.domain()[0] + c.domain()[1])))
+ .collect();
+ let n = pts.len().max(1) as f64;
+ pts.iter().fold(Vec3::ZERO, |acc, p| acc + *p) / n - c
+ }
+ _ => Vec3::ZERO,
+ };
+ if let Some(chart) = S3::from_analytic(&analytic, h, toward) {
+ surface = chart;
+ }
+ }
+ *report.surfaces.entry(analytic_name(&analytic).to_string()).or_insert(0) += 1;
+ let trim = trim::build(f, &local_curves, &surface, opts.trim_samples);
+ if let Some(why) = trim.unsupported {
+ report.unsupported_trims.push((base_face + fi, why.to_string()));
+ }
+ report.max_trim_chord = report.max_trim_chord.max(trim.chord_error);
+ let (mut lo, mut hi) = (trim.lo, trim.hi);
+ // Curved faces can bulge past their boundary: bound them by the whole surface's
+ // guaranteed box (spline hull, turned profile), clipped to nothing tighter.
+ if !matches!(surface, S3::Plane { .. })
+ && let Some((blo, bhi)) = surface.bound()
+ {
+ lo = lo.min(blo);
+ hi = hi.max(bhi);
+ }
+ // Every face is padded, planes too: a plane record and its edges may disagree by
+ // rounding, and a box flat along the normal would cull the plane's own hit. Rounding
+ // grows with where the body was modelled (its offset), not with the face's size.
+ let pad = (hi - lo).len() * 1e-6 + 1e-12 * offset.x.abs().max(offset.y.abs()).max(offset.z.abs());
+ lo -= Vec3::new(pad, pad, pad);
+ hi += Vec3::new(pad, pad, pad);
+ for u in f.loops.iter().flatten() {
+ if let Some(list) = users.get_mut(u.edge as usize) {
+ list.push(base_face + fi);
+ }
+ }
+ let freeform = matches!(analytic, Analytic::Other);
+ if freeform {
+ report.freeform_faces.push(base_face + fi);
+ }
+ faces.push(FaceData { surface, analytic, group: Vec::new(), trim, lo, hi, freeform });
+ }
+ for (ei, (c, acc)) in curves.into_iter().enumerate() {
+ let list = users.get(ei).cloned().unwrap_or_default();
+ let mut distinct = list.clone();
+ distinct.sort_unstable();
+ distinct.dedup();
+ let kind = if list.len() >= 2 && distinct.len() == 1 {
+ EdgeKind::Seam
+ } else if let [f1, f2] = distinct.as_slice() {
+ let [t0, t1] = c.domain();
+ let normals_parallel = [0.25, 0.5, 0.75].iter().all(|k| {
+ let m = c.at(t0 + (t1 - t0) * k);
+ let n = |f: usize| faces.get(f).and_then(|fd: &FaceData| fd.surface.inverse(m, None).and_then(|uv| fd.surface.normal(uv)));
+ n(*f1).zip(n(*f2)).is_some_and(|(a, b)| a.cross(b).len() < 1e-6)
+ });
+ let same_surface = match (faces.get(*f1).map(|f: &FaceData| f.analytic), faces.get(*f2).map(|f: &FaceData| f.analytic)) {
+ (Some(a), Some(b)) => same_analytic(&a, &b, 1e-9),
+ _ => false,
+ };
+ if same_surface {
+ EdgeKind::Seam
+ } else if normals_parallel {
+ EdgeKind::Tangent
+ } else {
+ EdgeKind::Sharp
+ }
+ } else {
+ EdgeKind::Sharp
+ };
+ match kind {
+ EdgeKind::Tangent => report.tangent_edges += 1,
+ EdgeKind::Seam => report.seam_edges += 1,
+ EdgeKind::Sharp => {}
+ }
+ edges.push(EdgeData { curve: c, acc, faces: list, kind });
+ }
+ }
+ // Faces on one quadric or torus. Only surfaces of one kind whose size (radius, half angle,
+ // major radius) agrees to the tolerance can match, so each face is compared with the faces
+ // in its window of the sorted sizes, not with every face.
+ let size = |a: &Analytic| match a {
+ Analytic::Cylinder { r, .. } => Some((0u8, *r)),
+ Analytic::Cone { half, .. } => Some((1, *half)),
+ Analytic::Sphere { r, .. } => Some((2, *r)),
+ Analytic::Torus { major, .. } => Some((3, *major)),
+ Analytic::Plane | Analytic::Other => None,
+ };
+ let analytics: Vec<Analytic> = faces.iter().map(|f| f.analytic).collect();
+ let mut sorted: Vec<(u8, f64, usize)> = analytics.iter().enumerate().filter_map(|(j, a)| size(a).map(|(k, v)| (k, v, j))).collect();
+ sorted.sort_by(|a, b| a.0.cmp(&b.0).then(a.1.total_cmp(&b.1)));
+ let mut compared = 0usize;
+ for (i, f) in faces.iter_mut().enumerate() {
+ if i % 256 == 0 && cancel() {
+ return Err(HlrError::Cancelled);
+ }
+ let mut group = vec![i];
+ if let Some((kind, v)) = size(&f.analytic) {
+ // Wider than any match allows: same_analytic takes sizes within 1e-9 of the size
+ // (relative for lengths, absolute for the half angle).
+ let reach = 2e-9 * v.abs().max(1.);
+ let first = sorted.partition_point(|c| c.0 < kind || (c.0 == kind && c.1 < v - reach));
+ for (_, _, j) in sorted.get(first..).unwrap_or_default().iter().take_while(|c| c.0 == kind && c.1 <= v + reach) {
+ compared += 1;
+ if compared > 50_000_000 {
+ return Err(HlrError::Budget("surface group"));
+ }
+ if compared.is_multiple_of(65536) && cancel() {
+ return Err(HlrError::Cancelled);
+ }
+ if *j != i && analytics.get(*j).is_some_and(|b| same_analytic(&f.analytic, b, 1e-9)) {
+ group.push(*j);
+ }
+ }
+ }
+ group.sort_unstable();
+ f.group = group;
+ }
+ report.faces = faces.len();
+ report.edges = edges.len();
+ let (lo, hi) =
+ faces.iter().fold((Vec3::new(f64::MAX, f64::MAX, f64::MAX), Vec3::new(f64::MIN, f64::MIN, f64::MIN)), |(a, b), f| (a.min(f.lo), b.max(f.hi)));
+ if faces.is_empty() || !lo.is_finite() || !hi.is_finite() {
+ return Err(HlrError::Invalid("empty or unbounded body"));
+ }
+ Ok(Prepared { edges, faces, offset, lo, hi, report })
+}
+
+/// The centre of the body's vertices' box (of its faces' reference points when it has no
+/// vertices, a sphere without edges say).
+fn anchor(b: &Brep) -> Vec3 {
+ use crate::brep::Surface;
+ let v3 = |p: &[f64; 3]| Vec3::new(p[0], p[1], p[2]);
+ let mut pts: Vec<Vec3> = b.shells.iter().flat_map(|s| s.vertices.iter().map(v3)).collect();
+ if pts.is_empty() {
+ pts = b
+ .shells
+ .iter()
+ .flat_map(|s| s.faces.iter())
+ .filter_map(|f| match &f.surface {
+ Surface::Plane { origin, .. } | Surface::PlaneThrough { origin, .. } | Surface::Revolution { origin, .. } => Some(v3(origin)),
+ Surface::PlacedRevolution { origin, matrix: [x, y, z, w], .. } => {
+ let column = |c: &[f64; 4]| Vec3::new(c[0], c[1], c[2]);
+ Some(column(x) * origin[0] + column(y) * origin[1] + column(z) * origin[2] + column(w))
+ }
+ Surface::Cylinder { frame, .. } | Surface::Cone { frame, .. } | Surface::Sphere { frame, .. } | Surface::Torus { frame, .. } => {
+ Some(v3(&frame.origin))
+ }
+ Surface::Spline { points, .. } => points.first().and_then(|r| r.first()).map(v3),
+ Surface::RationalSpline { homogeneous, .. } => {
+ homogeneous.first().and_then(|r| r.first()).filter(|h| h[3] != 0.).map(|h| Vec3::new(h[0] / h[3], h[1] / h[3], h[2] / h[3]))
+ }
+ })
+ .collect();
+ }
+ let Some(first) = pts.first().copied() else { return Vec3::ZERO };
+ let (lo, hi) = pts.iter().fold((first, first), |(lo, hi), p| (lo.min(*p), hi.max(*p)));
+ let c = (lo + hi) * 0.5;
+ if c.is_finite() { c } else { Vec3::ZERO }
+}
+
+/// The body's records with every position moved by `-d`.
+fn shifted(b: &Brep, d: Vec3) -> Brep {
+ use crate::brep::{Curve, Surface};
+ fn point(p: &mut [f64; 3], d: Vec3) {
+ p[0] -= d.x;
+ p[1] -= d.y;
+ p[2] -= d.z;
+ }
+ fn weighted(h: &mut [f64; 4], d: Vec3) {
+ h[0] -= d.x * h[3];
+ h[1] -= d.y * h[3];
+ h[2] -= d.z * h[3];
+ }
+ fn curve(c: &mut Curve, d: Vec3) {
+ match c {
+ Curve::Line { start, end } => {
+ point(start, d);
+ point(end, d);
+ }
+ Curve::CircleArc { frame, .. } | Curve::EllipseArc { frame, .. } => point(&mut frame.origin, d),
+ Curve::Polyline { points } | Curve::Spline { points, .. } | Curve::Intersection { points, .. } => {
+ points.iter_mut().for_each(|p| point(p, d))
+ }
+ Curve::RationalSpline { homogeneous, .. } => homogeneous.iter_mut().for_each(|h| weighted(h, d)),
+ Curve::SurfaceIntersection { surfaces, leader, .. } => {
+ surfaces.iter_mut().for_each(|s| surface(s, d));
+ curve(leader, d);
+ }
+ }
+ }
+ fn surface(s: &mut Surface, d: Vec3) {
+ match s {
+ Surface::Plane { origin, .. } => point(origin, d),
+ Surface::PlaneThrough { origin, u_point, v_point } => [origin, u_point, v_point].into_iter().for_each(|p| point(p, d)),
+ Surface::Cylinder { frame, .. } | Surface::Cone { frame, .. } | Surface::Sphere { frame, .. } | Surface::Torus { frame, .. } => {
+ point(&mut frame.origin, d)
+ }
+ Surface::Spline { points, .. } => points.iter_mut().flatten().for_each(|p| point(p, d)),
+ Surface::RationalSpline { homogeneous, .. } => homogeneous.iter_mut().flatten().for_each(|h| weighted(h, d)),
+ Surface::Revolution { profile, origin, .. } => {
+ curve(profile, d);
+ point(origin, d);
+ }
+ // The placement's last column carries its translation (and the homogeneous weight).
+ Surface::PlacedRevolution { matrix: [.., w], .. } => weighted(w, d),
+ }
+ }
+ let mut out = b.clone();
+ for s in &mut out.shells {
+ s.vertices.iter_mut().for_each(|p| point(p, d));
+ s.edges.iter_mut().for_each(|e| curve(&mut e.curve, d));
+ s.faces.iter_mut().for_each(|f| surface(&mut f.surface, d));
+ }
+ out
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct Options {
+ /// Draw edges between tangent faces (seams are never drawn).
+ pub tangent_edges: bool,
+ /// Also handle freeform faces: contoured silhouettes and seeded ray tests, slow and
+ /// ill-conditioned where a face is seen nearly edge-on (W05a finding 6). Off by default.
+ pub freeform: bool,
+ /// Boundary samples per curve piece when trimming faces, 1 to [`MAX_TRIM_SAMPLES`].
+ pub trim_samples: usize,
+ pub max_tracks: usize,
+ pub max_rays: usize,
+}
+
+impl Default for Options {
+ fn default() -> Self {
+ Options { tangent_edges: true, freeform: false, trim_samples: 256, max_tracks: 200_000, max_rays: 20_000_000 }
+ }
+}
+
+/// Largest [`Options::trim_samples`].
+pub const MAX_TRIM_SAMPLES: usize = 4096;
+/// Largest coordinate of a placed body in the scene, in millimetres: the bound `geom::section`
+/// and `geom::brep` put on stored numbers. Beyond it the scene's size, and every tolerance
+/// taken from it, would lose its meaning or overflow.
+pub const MAX_COORDINATE: f64 = 1e12;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub enum Visibility {
+ Visible,
+ Hidden,
+ Uncertain,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Serialize)]
+#[serde(tag = "kind", rename_all = "snake_case")]
+pub enum Source {
+ Edge {
+ edge: usize,
+ tangent: bool,
+ },
+ /// The silhouette of the faces on one surface; `face` is the first of them.
+ Silhouette {
+ face: usize,
+ },
+}
+
+#[derive(Clone, Debug, Serialize)]
+pub struct Piece {
+ /// Parameter range on the source curve.
+ pub t: [f64; 2],
+ pub visibility: Visibility,
+ /// Drawn by another piece: a hidden or uncertain piece lying on a visible one (hidden lines
+ /// never show through visible ones), or a duplicate of a visible or hidden piece.
+ pub covered: bool,
+ /// The piece on screen (millimetres): lines and conic arcs where the projection is exact,
+ /// chords otherwise.
+ pub geometry: Vec<Seg2>,
+ pub accuracy: CurveAccuracy,
+ /// Exact points along the piece, joined by `geometry`'s chords where it is sampled.
+ #[serde(skip)]
+ points: Vec<[f64; 2]>,
+ /// Largest distance between the projected curve and the chords joining `points`.
+ #[serde(skip)]
+ sag: f64,
+}
+
+#[derive(Clone, Debug, Serialize)]
+pub struct Line {
+ /// Index into the scene's placements.
+ pub placement: usize,
+ pub source: Source,
+ pub pieces: Vec<Piece>,
+}
+
+/// A face left out of the supported subset, and why.
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct Unsupported {
+ pub placement: usize,
+ pub face: usize,
+ pub reason: &'static str,
+}
+
+#[derive(Clone, Debug, Default, Serialize)]
+pub struct Stats {
+ pub tracks: usize,
+ pub silhouettes: usize,
+ pub crossings: usize,
+ pub pieces: usize,
+ pub uncertain_pieces: usize,
+ /// Uncertain pieces not covered by a coincident visible piece.
+ pub uncertain_uncovered: usize,
+ pub covered_pieces: usize,
+ /// Visibility changes found inside a piece by sampling, i.e. not at a computed crossing.
+ pub unexpected_transitions: usize,
+ pub rays: usize,
+ pub surface_ray_tests: usize,
+ /// Milliseconds per phase: curves and silhouettes, crossings, classification, coverage.
+ /// Zero where the platform has no clock (`wasm32-unknown-unknown`).
+ pub phase_ms: [f64; 4],
+}
+
+#[derive(Clone, Debug, Default, Serialize)]
+pub struct Drawing {
+ pub lines: Vec<Line>,
+ /// Faces outside the supported subset: their silhouettes are missing and what they could
+ /// hide is uncertain.
+ pub unsupported: Vec<Unsupported>,
+ pub stats: Stats,
+}
+
+enum TrackCurve<'a> {
+ Edge(&'a C3),
+ Owned(C3),
+}
+
+struct Track<'a> {
+ placement: usize,
+ curve: TrackCurve<'a>,
+ range: [f64; 2],
+ source: Source,
+ acc: CurveAccuracy,
+ own: Vec<usize>,
+ /// Own-face hits closer than this are the curve's own surface: a sampled silhouette's
+ /// chord lies up to its deviation inside the surface, and a ray tangent there leaves it
+ /// again after about sqrt(2 * radius * deviation).
+ own_eps: f64,
+ samples: Vec<(f64, [f64; 2])>,
+ /// Per sample chord: the distance of the exact projected curve from it at its middle.
+ sags: Vec<f64>,
+ splits: Vec<f64>,
+}
+
+impl Track<'_> {
+ fn c3(&self) -> &C3 {
+ match &self.curve {
+ TrackCurve::Edge(c) => c,
+ TrackCurve::Owned(c) => c,
+ }
+ }
+}
+
+struct Ctx<'a> {
+ defs: &'a [Prepared],
+ scene: &'a [Placement],
+ view: View,
+ eps_own: f64,
+ eps_other: f64,
+ scale: f64,
+ /// World boxes of placements, screen min/max and depth min.
+ boxes: Vec<([f64; 2], [f64; 2], f64)>,
+ rays: std::cell::Cell<usize>,
+ surface_tests: std::cell::Cell<usize>,
+ transitions: std::cell::Cell<usize>,
+ max_rays: usize,
+ freeform: bool,
+ cancel: &'a dyn Fn() -> bool,
+}
+
+fn context<'a>(defs: &'a [Prepared], scene: &'a [Placement], view: &View, opts: &Options, cancel: &'a dyn Fn() -> bool) -> Result<Ctx<'a>, HlrError> {
+ let mut boxes = Vec::with_capacity(scene.len());
+ let (mut wlo, mut whi) = (Vec3::new(f64::MAX, f64::MAX, f64::MAX), Vec3::new(f64::MIN, f64::MIN, f64::MIN));
+ for p in scene {
+ if !p.rigid() {
+ return Err(HlrError::Invalid("placement (not a rotation and translation)"));
+ }
+ let def = defs.get(p.body).ok_or(HlrError::Invalid("placement body index"))?;
+ let (mut slo, mut shi, mut dmin) = ([f64::MAX; 2], [f64::MIN; 2], f64::MAX);
+ for k in 0..8 {
+ let c = Vec3::new(
+ if k & 1 == 0 { def.lo.x } else { def.hi.x },
+ if k & 2 == 0 { def.lo.y } else { def.hi.y },
+ if k & 4 == 0 { def.lo.z } else { def.hi.z },
+ );
+ let w = p.apply(c);
+ wlo = wlo.min(w);
+ whi = whi.max(w);
+ let s = view.screen(w);
+ slo = [slo[0].min(s[0]), slo[1].min(s[1])];
+ shi = [shi[0].max(s[0]), shi[1].max(s[1])];
+ dmin = dmin.min(w.dot(view.d));
+ }
+ boxes.push((slo, shi, dmin));
+ }
+ let scale = if scene.is_empty() { 1. } else { (whi - wlo).len().max(1e-6) };
+ Ok(Ctx {
+ defs,
+ scene,
+ view: *view,
+ eps_own: 1e-6 * scale,
+ // Hits on other bodies closer than rounding are ignored, the rest up to eps_own are
+ // uncertain: the work is done in a frame at the scene's centre, so rounding is about
+ // 1e-16 of the coordinates, far below 1e-12 of the scene.
+ eps_other: 1e-12 * scale,
+ scale,
+ boxes,
+ rays: std::cell::Cell::new(0),
+ surface_tests: std::cell::Cell::new(0),
+ transitions: std::cell::Cell::new(0),
+ max_rays: opts.max_rays,
+ freeform: opts.freeform,
+ cancel,
+ })
+}
+
+pub fn hidden_lines(defs: &[Prepared], scene: &[Placement], view: &View, opts: &Options, cancel: &dyn Fn() -> bool) -> Result<Drawing, HlrError> {
+ // Work in a frame centred on the scene: coordinates stay small, so rounding does not grow
+ // with the distance from the origin (W05a finding 7). Results are shifted back at the end.
+ let origin = scene_centre(defs, scene)?;
+ // Each body's own offset (see `Prepared`) joins its placement here.
+ let local: Vec<Placement> =
+ scene.iter().map(|p| Placement { translation: p.apply(defs.get(p.body).map_or(Vec3::ZERO, |d| d.offset)) - origin, ..*p }).collect();
+ let scene = local.as_slice();
+ let shift = view.screen(origin);
+ let ctx = context(defs, scene, view, opts, cancel)?;
+ let scale = ctx.scale;
+ let mut stats = Stats::default();
+ let mut unsupported = Vec::new();
+ let clock = Clock::start();
+ // 1. Tracks: drawable edges and trimmed silhouettes of every placement.
+ let mut tracks: Vec<Track> = Vec::new();
+ for (pi, p) in scene.iter().enumerate() {
+ if cancel() {
+ return Err(HlrError::Cancelled);
+ }
+ let Some(def) = defs.get(p.body) else { continue };
+ // A body's records were rounded where it was modelled: a plane may stand an ulp of
+ // those coordinates off its edges, which matters for a part far smaller than its
+ // distance from the origin.
+ let far = 1e-14 * def.offset.x.abs().max(def.offset.y.abs()).max(def.offset.z.abs());
+ for (ei, e) in def.edges.iter().enumerate() {
+ if e.kind == EdgeKind::Seam || (e.kind == EdgeKind::Tangent && !opts.tangent_edges) {
+ continue;
+ }
+ tracks.push(Track {
+ placement: pi,
+ curve: TrackCurve::Edge(&e.curve),
+ range: e.curve.domain(),
+ source: Source::Edge { edge: ei, tangent: e.kind == EdgeKind::Tangent },
+ acc: e.acc,
+ own: e.faces.clone(),
+ // Skip the ray's own start on its faces: rounding grows with the coordinates
+ // (1e-9 of the scene), the margin with the faces themselves (1e-6 of their
+ // size), never with the whole scene, so small parts in large scenes keep their
+ // self-occlusion.
+ own_eps: {
+ let size = e.faces.iter().filter_map(|f| def.faces.get(*f)).map(|f| (f.hi - f.lo).len()).fold(0., f64::max);
+ let base = (1e-9 * ctx.scale).max(1e-6 * size).max(far);
+ match e.acc {
+ CurveAccuracy::Bounded { max_deviation_mm: tol } => base.max(10. * tol),
+ _ => base,
+ }
+ },
+ samples: Vec::new(),
+ sags: Vec::new(),
+ splits: Vec::new(),
+ });
+ }
+ let dl = p.local_dir(view.d);
+ let supported = |f: &FaceData| !(f.freeform && !opts.freeform) && f.trim.unsupported.is_none();
+ // Faces on one surface (a sphere in two halves, say) share their silhouettes, keyed by
+ // the set's first face: one curve along their seams, not one per face.
+ let mut sets: std::collections::BTreeMap<usize, Vec<usize>> = std::collections::BTreeMap::new();
+ for (fi, f) in def.faces.iter().enumerate() {
+ if f.freeform && !opts.freeform {
+ unsupported.push(Unsupported { placement: pi, face: fi, reason: "freeform face" });
+ continue;
+ }
+ if let Some(reason) = f.trim.unsupported {
+ unsupported.push(Unsupported { placement: pi, face: fi, reason });
+ continue;
+ }
+ if matches!(f.analytic, Analytic::Plane) {
+ continue;
+ }
+ // The set's silhouette is traced on its first face's surface, so a face joins only
+ // when its recognised surface is that one to rounding (1e-13); recognition groups
+ // surfaces more loosely (1e-9), and two surfaces that close can still differ inside
+ // the faces (two spherical caps through one circle).
+ let first = f.group.iter().copied().filter(|j| def.faces.get(*j).is_some_and(supported)).min().unwrap_or(fi);
+ let fits = def.faces.get(first).is_some_and(|l| same_analytic(&l.analytic, &f.analytic, 1e-13));
+ sets.entry(if fits { first } else { fi }).or_default().push(fi);
+ }
+ for (fi, members) in sets {
+ let Some(f) = def.faces.get(fi) else { continue };
+ let parts: Vec<(&S3, &Trim)> = members.iter().filter_map(|j| def.faces.get(*j)).map(|m| (&m.surface, &m.trim)).collect();
+ let size = members.iter().filter_map(|j| def.faces.get(*j)).map(|m| (m.hi - m.lo).len()).fold(0., f64::max);
+ let mut sils = Vec::new();
+ silhouette::silhouettes(&parts, f.analytic, dl, &mut sils);
+ for s in sils {
+ for r in &s.ranges {
+ stats.silhouettes += 1;
+ tracks.push(Track {
+ placement: pi,
+ curve: TrackCurve::Owned(s.curve.clone()),
+ range: *r,
+ source: Source::Silhouette { face: fi },
+ acc: s.acc,
+ own: f.group.clone(),
+ own_eps: match s.acc {
+ CurveAccuracy::Sampled { max_sample_deviation_mm: dev } => {
+ (1e-9 * ctx.scale).max(1e-6 * size).max(far).max(2. * (2. * size * dev).sqrt())
+ }
+ _ => (1e-9 * ctx.scale).max(1e-6 * size).max(far),
+ },
+ samples: Vec::new(),
+ sags: Vec::new(),
+ splits: Vec::new(),
+ });
+ }
+ }
+ }
+ if tracks.len() > opts.max_tracks {
+ return Err(HlrError::Budget("curve"));
+ }
+ }
+ stats.tracks = tracks.len();
+ // 2. Screen samples.
+ for (ti, t) in tracks.iter_mut().enumerate() {
+ if ti % 64 == 0 && cancel() {
+ return Err(HlrError::Cancelled);
+ }
+ let Some(p) = scene.get(t.placement) else { continue };
+ let c = t.c3();
+ let mut ts: Vec<f64> = c.breaks().into_iter().filter(|x| *x > t.range[0] && *x < t.range[1]).collect();
+ ts.push(t.range[0]);
+ ts.push(t.range[1]);
+ ts.sort_by(f64::total_cmp);
+ let per = match c {
+ C3::Line { .. } => 1,
+ C3::Polyline(_) => 1,
+ _ => 32,
+ };
+ let mut params = Vec::new();
+ for w in ts.windows(2) {
+ let (Some(a), Some(b)) = (w.first(), w.get(1)) else { continue };
+ for i in 0..per {
+ params.push(a + (b - a) * i as f64 / per as f64);
+ }
+ }
+ params.push(t.range[1]);
+ let screen = |x: f64| view.screen(p.apply(c.at(x)));
+ let mut samples: Vec<(f64, [f64; 2])> = params.into_iter().map(|x| (x, screen(x))).collect();
+ // Halve chords of exact curves until their sag on screen is within the target, so
+ // chords stand for the curve closely enough for coincidence and crossing tests.
+ if !matches!(c, C3::Line { .. } | C3::Polyline(_)) {
+ let target = 1e-7 * scale.max(1.);
+ for _ in 0..12 {
+ let mut next = Vec::with_capacity(samples.len() * 2);
+ let mut split = false;
+ for w in samples.windows(2) {
+ let (Some(a), Some(b)) = (w.first(), w.get(1)) else { continue };
+ next.push(*a);
+ let m = 0.5 * (a.0 + b.0);
+ let q = screen(m);
+ // A spline's piece is held by its control points' hull: a parameterisation
+ // racing between samples cannot hide a swerve from the chord.
+ let hull =
+ c.hull([a.0, b.0]).map_or(0., |h| h.iter().map(|x| point_segment(view.screen(p.apply(*x)), a.1, b.1)).fold(0., f64::max));
+ if point_segment(q, a.1, b.1).max(hull) > target && next.len() < 1 << 16 {
+ next.push((m, q));
+ split = true;
+ }
+ }
+ if let Some(last) = samples.last() {
+ next.push(*last);
+ }
+ samples = next;
+ if !split {
+ break;
+ }
+ }
+ }
+ // Chord sag on screen: exact for lines, measured at the middle for curves; a sampled
+ // silhouette's chords stand for the true curve to within its measured deviation.
+ // A fitted source record stands for the true curve to within its bound.
+ let fitted = match t.acc {
+ CurveAccuracy::Bounded { max_deviation_mm: tol } => tol,
+ _ => 0.,
+ };
+ let sags = samples
+ .windows(2)
+ .map(|w| {
+ fitted
+ + match (c, w.first(), w.get(1)) {
+ (C3::Line { .. }, _, _) => 0.,
+ (C3::Polyline(_), _, _) => match t.acc {
+ CurveAccuracy::Sampled { max_sample_deviation_mm: dev } => dev,
+ _ => 0.,
+ },
+ (_, Some(a), Some(b)) => {
+ let hull = c
+ .hull([a.0, b.0])
+ .map_or(0., |h| h.iter().map(|x| point_segment(view.screen(p.apply(*x)), a.1, b.1)).fold(0., f64::max));
+ point_segment(view.screen(p.apply(c.at(0.5 * (a.0 + b.0)))), a.1, b.1).max(hull)
+ }
+ _ => 0.,
+ }
+ })
+ .collect();
+ t.samples = samples;
+ t.sags = sags;
+ }
+ stats.phase_ms[0] = clock.lap();
+ // 3. Crossings between projected curves (and each curve with itself).
+ stats.crossings = crossings(&mut tracks, &ctx)?;
+ // Faces left out (freeform or with an unsupported trim) draw no silhouettes to cut at, so
+ // the curves are cut where they cross each such face's screen box instead, and below a
+ // piece inside a box and behind its nearest point is uncertain: it may be hidden.
+ let shadows = ShadowIndex::new(shadow_boxes(defs, scene, view, &unsupported))?;
+ let mut near = Vec::new();
+ let mut checks = 0usize;
+ for (ti, t) in tracks.iter_mut().enumerate() {
+ if shadows.list.is_empty() {
+ break;
+ }
+ if ti % 64 == 0 && cancel() {
+ return Err(HlrError::Cancelled);
+ }
+ let Some(pl) = scene.get(t.placement) else { continue };
+ let mut cuts = Vec::new();
+ for w in t.samples.windows(2) {
+ let (Some(a), Some(b)) = (w.first(), w.get(1)) else { continue };
+ // The curve's own screen box between the two samples: it can reach past the chord,
+ // across it or along it (a view along an arc's plane folds it back on itself).
+ let (lo, hi) = screen_box(t.c3(), [a.0, b.0], pl, view);
+ shadows.query(lo, hi, &mut near);
+ checks = checks.saturating_add(near.len());
+ if checks > 500_000_000 {
+ return Err(HlrError::Budget("shadow"));
+ }
+ for sh in near.iter().filter_map(|k| shadows.list.get(*k)) {
+ for (k, edge) in [(0usize, sh.lo[0]), (0, sh.hi[0]), (1, sh.lo[1]), (1, sh.hi[1])] {
+ let (u, v) = (a.1[k], b.1[k]);
+ if (u - edge) * (v - edge) < 0. {
+ // Where the curve itself crosses the side, not its chord.
+ let side = |x: f64| view.screen(pl.apply(t.c3().at(x))).get(k).copied().unwrap_or(0.) - edge;
+ let (mut lo, mut hi) = (a.0, b.0);
+ for _ in 0..60 {
+ let mid = 0.5 * (lo + hi);
+ if (side(mid) < 0.) == (u - edge < 0.) {
+ lo = mid;
+ } else {
+ hi = mid;
+ }
+ }
+ cuts.push(0.5 * (lo + hi));
+ }
+ }
+ // A curve that enters the box where its chord does not: its stretch becomes a
+ // piece of its own, judged below.
+ if overlaps(lo, hi, sh) && box_gap(a.1, b.1, sh.lo, sh.hi) > 0. {
+ cuts.push(a.0);
+ cuts.push(b.0);
+ }
+ }
+ }
+ t.splits.extend(cuts);
+ }
+ stats.phase_ms[1] = clock.lap();
+ // 4. Classify pieces between splits.
+ let mut lines = Vec::with_capacity(tracks.len());
+ for (ti, t) in tracks.iter().enumerate() {
+ if ti % 64 == 0 && cancel() {
+ return Err(HlrError::Cancelled);
+ }
+ let c = t.c3();
+ let mut cuts = t.splits.clone();
+ cuts.push(t.range[0]);
+ cuts.push(t.range[1]);
+ cuts.retain(|x| *x >= t.range[0] && *x <= t.range[1]);
+ cuts.sort_by(f64::total_cmp);
+ let span = t.range[1] - t.range[0];
+ // Cuts merge when their parameters and their points are both close: nearby parameters
+ // alone do not tell (a knot span narrower than 1e-10 of the range can carry most of a
+ // circle), nor do equal points (a closed curve's two ends).
+ cuts.dedup_by(|a, b| *a == *b || ((*a - *b).abs() <= 1e-10 * span && c.at(*a).dist(c.at(*b)) <= 1e-9 * scale.max(1.)));
+ let mut pieces: Vec<Piece> = Vec::new();
+ for w in cuts.windows(2) {
+ let (Some(&a), Some(&b)) = (w.first(), w.get(1)) else { continue };
+ for (r, vis) in classify_range(t, a, b, &ctx)? {
+ let vis = if vis == Visibility::Visible && in_shadow(t, r, scene, view, &shadows) { Visibility::Uncertain } else { vis };
+ match pieces.last_mut() {
+ Some(last) if last.visibility == vis && (last.t[1] - r[0]).abs() <= 1e-12 * span.max(1e-300) => last.t[1] = r[1],
+ _ => pieces.push(Piece {
+ t: r,
+ visibility: vis,
+ covered: false,
+ geometry: Vec::new(),
+ accuracy: t.acc,
+ points: Vec::new(),
+ sag: 0.,
+ }),
+ }
+ }
+ }
+ let p = scene.get(t.placement).ok_or(HlrError::Invalid("placement"))?;
+ for piece in &mut pieces {
+ let mut pts = vec![view.screen(p.apply(c.at(piece.t[0])))];
+ pts.extend(t.samples.iter().filter(|(x, _)| *x > piece.t[0] && *x < piece.t[1]).map(|(_, s)| *s));
+ pts.push(view.screen(p.apply(c.at(piece.t[1]))));
+ piece.points = pts;
+ piece.sag = t
+ .samples
+ .windows(2)
+ .zip(&t.sags)
+ .filter(|(w, _)| w.get(1).is_some_and(|b| b.0 > piece.t[0]) && w.first().is_some_and(|a| a.0 < piece.t[1]))
+ .map(|(_, sag)| *sag)
+ .fold(0., f64::max);
+ }
+ stats.pieces += pieces.len();
+ stats.uncertain_pieces += pieces.iter().filter(|p| p.visibility == Visibility::Uncertain).count();
+ lines.push(Line { placement: t.placement, source: t.source, pieces });
+ }
+ stats.phase_ms[2] = clock.lap();
+ // Coverage is checked every 1e-4 of the scene (5 um to 0.5 mm): a gap narrower than that
+ // in a coincident line is not seen.
+ cover(&mut lines, 1e-7 + 1e-9 * scale, (1e-4 * scale).clamp(0.005, 0.5), cancel)?;
+ stats.phase_ms[3] = clock.lap();
+ for p in lines.iter().flat_map(|l| l.pieces.iter()) {
+ stats.covered_pieces += usize::from(p.covered);
+ stats.uncertain_uncovered += usize::from(p.visibility == Visibility::Uncertain && !p.covered);
+ }
+ stats.rays = ctx.rays.get();
+ stats.surface_ray_tests = ctx.surface_tests.get();
+ stats.unexpected_transitions = ctx.transitions.get();
+ // Output geometry, back in the caller's frame.
+ let shifted = |q: [f64; 2]| [q[0] + shift[0], q[1] + shift[1]];
+ for (l, t) in lines.iter_mut().zip(&tracks) {
+ let p = scene.get(t.placement).ok_or(HlrError::Invalid("placement"))?;
+ for piece in &mut l.pieces {
+ let (geometry, accuracy) = piece_geometry(t, piece, p, view);
+ piece.geometry = geometry.into_iter().map(|g| shift_seg(g, shift)).collect();
+ piece.accuracy = accuracy;
+ piece.points = piece.points.iter().map(|q| shifted(*q)).collect();
+ }
+ }
+ Ok(Drawing { lines, unsupported, stats })
+}
+
+/// The centre of the placed bodies' boxes, after checking the placements.
+/// A left-out face's screen box and the depth of its nearest corner.
+struct Shadow {
+ lo: [f64; 2],
+ hi: [f64; 2],
+ near: f64,
+}
+
+fn shadow_boxes(defs: &[Prepared], scene: &[Placement], view: &View, left_out: &[Unsupported]) -> Vec<Shadow> {
+ let mut out = Vec::new();
+ for u in left_out {
+ let Some(p) = scene.get(u.placement) else { continue };
+ let Some(f) = defs.get(p.body).and_then(|d| d.faces.get(u.face)) else { continue };
+ let (mut lo, mut hi, mut near) = ([f64::MAX; 2], [f64::MIN; 2], f64::MAX);
+ for k in 0..8 {
+ let c = Vec3::new(
+ if k & 1 == 0 { f.lo.x } else { f.hi.x },
+ if k & 2 == 0 { f.lo.y } else { f.hi.y },
+ if k & 4 == 0 { f.lo.z } else { f.hi.z },
+ );
+ let w = p.apply(c);
+ let s = view.screen(w);
+ lo = [lo[0].min(s[0]), lo[1].min(s[1])];
+ hi = [hi[0].max(s[0]), hi[1].max(s[1])];
+ near = near.min(w.dot(view.d));
+ }
+ out.push(Shadow { lo, hi, near });
+ }
+ out
+}
+
+/// Whether the piece `r` of a track may lie behind a left-out face, its own faces included (a
+/// curled face can hide its own edge closer than the own-face margin).
+fn in_shadow(t: &Track, r: [f64; 2], scene: &[Placement], view: &View, shadows: &ShadowIndex) -> bool {
+ if shadows.list.is_empty() {
+ return false;
+ }
+ let Some(p) = scene.get(t.placement) else { return false };
+ let c = t.c3();
+ // The piece is cut at the boxes' sides and where its curve enters a box between samples:
+ // it is in a box when its own screen box overlaps it and, for a piece holding samples, its
+ // middle or one of those samples lies in it (its ends may sit on the side it was cut at).
+ // Then it is in the shadow when its depth can pass the face's nearest point anywhere along
+ // it: the bound comes from the curve itself (its control points' hull, an arc's reach),
+ // not from samples, which a dip in depth that the screen does not show could fall between.
+ let (lo, hi) = screen_box(c, r, p, view);
+ let mut near = Vec::new();
+ shadows.query(lo, hi, &mut near);
+ if near.is_empty() {
+ return false;
+ }
+ let inner: Vec<[f64; 2]> = t.samples.iter().filter(|q| q.0 > r[0] && q.0 < r[1]).map(|q| q.1).collect();
+ let mid = view.screen(p.apply(c.at(0.5 * (r[0] + r[1]))));
+ let deepest = depth_bound(c, r, p, view.d);
+ near.iter().filter_map(|k| shadows.list.get(*k)).any(|sh| {
+ let within = |s: &[f64; 2]| s[0] >= sh.lo[0] && s[0] <= sh.hi[0] && s[1] >= sh.lo[1] && s[1] <= sh.hi[1];
+ deepest > sh.near && overlaps(lo, hi, sh) && (inner.is_empty() || within(&mid) || inner.iter().any(within))
+ })
+}
+
+/// Whether the box `lo hi` and a shadow's box share some area.
+fn overlaps(lo: [f64; 2], hi: [f64; 2], sh: &Shadow) -> bool {
+ lo[0] < sh.hi[0] && hi[0] > sh.lo[0] && lo[1] < sh.hi[1] && hi[1] > sh.lo[1]
+}
+
+/// The screen box of the curve's part `r` placed by `p`: a line's ends, an arc's ends and its
+/// extremes along each screen axis, the projected control points a spline's part depends on
+/// (they hold it), a polyline's vertices.
+fn screen_box(c: &C3, r: [f64; 2], p: &Placement, view: &View) -> ([f64; 2], [f64; 2]) {
+ let s = |q: Vec3| view.screen(p.apply(q));
+ let mut pts = vec![s(c.at(r[0])), s(c.at(r[1]))];
+ match c {
+ C3::Line { .. } => {}
+ C3::Arc { x, y, r: rad, .. } => {
+ // On screen: centre + U cos t + V sin t; each axis peaks where tan t = V_k / U_k.
+ let lin = |w: Vec3| view.screen(p.apply(w) - p.translation);
+ let (u, v) = (lin(*x * rad[0]), lin(*y * rad[1]));
+ for k in 0..2 {
+ let (Some(&uk), Some(&vk)) = (u.get(k), v.get(k)) else { continue };
+ // The peaks at base + k pi from the first one past the part's start, wherever
+ // its angles are counted from.
+ let (base, pi) = (vk.atan2(uk), std::f64::consts::PI);
+ let first = ((r[0] - base) / pi).ceil();
+ for k in 0..8 {
+ let t = base + (first + k as f64) * pi;
+ if t >= r[1] {
+ break;
+ }
+ if t > r[0] {
+ pts.push(s(c.at(t)));
+ }
+ }
+ }
+ }
+ C3::Spline { degree, knots, points, .. } => match c.hull(r) {
+ Some(h) => pts.extend(h.into_iter().map(s)),
+ None => pts.extend(
+ points
+ .iter()
+ .enumerate()
+ .filter(|(i, h)| h[3] > 0. && knots.get(*i).zip(knots.get(i + degree + 1)).is_some_and(|(lo, hi)| *lo < r[1] && *hi > r[0]))
+ .map(|(_, h)| s(Vec3::new(h[0] / h[3], h[1] / h[3], h[2] / h[3]))),
+ ),
+ },
+ C3::Polyline(v) => pts.extend(v.iter().enumerate().filter(|(i, _)| (*i as f64) > r[0] && (*i as f64) < r[1]).map(|(_, q)| s(*q))),
+ }
+ let lo = pts.iter().fold([f64::MAX; 2], |m, q| [m[0].min(q[0]), m[1].min(q[1])]);
+ let hi = pts.iter().fold([f64::MIN; 2], |m, q| [m[0].max(q[0]), m[1].max(q[1])]);
+ (lo, hi)
+}
+
+/// Left-out faces' boxes on a uniform screen grid, so a curve meets only those near it.
+struct ShadowIndex {
+ list: Vec<Shadow>,
+ lo: [f64; 2],
+ hi: [f64; 2],
+ cell: [f64; 2],
+ n: usize,
+ buckets: Vec<Vec<usize>>,
+}
+
+impl ShadowIndex {
+ fn new(list: Vec<Shadow>) -> Result<ShadowIndex, HlrError> {
+ let (mut lo, mut hi) = ([f64::MAX; 2], [f64::MIN; 2]);
+ for sh in &list {
+ lo = [lo[0].min(sh.lo[0]), lo[1].min(sh.lo[1])];
+ hi = [hi[0].max(sh.hi[0]), hi[1].max(sh.hi[1])];
+ }
+ let n = ((list.len() as f64).sqrt().ceil() as usize).clamp(1, 1024);
+ let cell = [((hi[0] - lo[0]) / n as f64).max(1e-12), ((hi[1] - lo[1]) / n as f64).max(1e-12)];
+ let mut index = ShadowIndex { list: Vec::new(), lo, hi, cell, n, buckets: vec![Vec::new(); n * n] };
+ let mut entries = 0usize;
+ for (k, sh) in list.iter().enumerate() {
+ let (a, b) = (index.cell_of(sh.lo), index.cell_of(sh.hi));
+ entries = entries.saturating_add((b[0] - a[0] + 1).saturating_mul(b[1] - a[1] + 1));
+ if entries > 50_000_000 {
+ return Err(HlrError::Budget("shadow grid"));
+ }
+ for y in a[1]..=b[1] {
+ for x in a[0]..=b[0] {
+ if let Some(bucket) = index.buckets.get_mut(y * n + x) {
+ bucket.push(k);
+ }
+ }
+ }
+ }
+ index.list = list;
+ Ok(index)
+ }
+
+ fn cell_of(&self, p: [f64; 2]) -> [usize; 2] {
+ let f = |k: usize| (((p[k] - self.lo[k]) / self.cell[k]).floor().clamp(0., (self.n - 1) as f64)) as usize;
+ [f(0), f(1)]
+ }
+
+ /// The boxes in the cells the box `lo hi` touches, each once.
+ fn query(&self, lo: [f64; 2], hi: [f64; 2], out: &mut Vec<usize>) {
+ out.clear();
+ if self.list.is_empty() || hi[0] < self.lo[0] || hi[1] < self.lo[1] || lo[0] > self.hi[0] || lo[1] > self.hi[1] {
+ return;
+ }
+ let (a, b) = (self.cell_of(lo), self.cell_of(hi));
+ for y in a[1]..=b[1] {
+ for x in a[0]..=b[0] {
+ if let Some(bucket) = self.buckets.get(y * self.n + x) {
+ out.extend_from_slice(bucket);
+ }
+ }
+ }
+ out.sort_unstable();
+ out.dedup();
+ }
+}
+
+/// An upper bound of the depth along `d` of the curve's part `r` placed by `p`: a line's ends,
+/// an arc's centre plus its reach, the projected control points a spline's part depends on
+/// (its weights are positive, so the part lies in their hull), a polyline's vertices.
+fn depth_bound(c: &C3, r: [f64; 2], p: &Placement, d: Vec3) -> f64 {
+ let depth = |q: Vec3| p.apply(q).dot(d);
+ match c {
+ C3::Line { .. } => depth(c.at(r[0])).max(depth(c.at(r[1]))),
+ C3::Arc { o, x, y, r: rad, .. } => {
+ let dl = p.local_dir(d);
+ depth(*o) + (rad[0] * x.dot(dl)).hypot(rad[1] * y.dot(dl))
+ }
+ C3::Spline { degree, knots, points, .. } => match c.hull(r) {
+ Some(h) => h.into_iter().map(depth).fold(f64::MIN, f64::max),
+ None => points
+ .iter()
+ .enumerate()
+ .filter(|(i, h)| h[3] > 0. && knots.get(*i).zip(knots.get(i + degree + 1)).is_some_and(|(lo, hi)| *lo < r[1] && *hi > r[0]))
+ .map(|(_, h)| depth(Vec3::new(h[0] / h[3], h[1] / h[3], h[2] / h[3])))
+ .fold(f64::MIN, f64::max),
+ }
+ .max(depth(c.at(r[0])))
+ .max(depth(c.at(r[1]))),
+ C3::Polyline(pts) => pts
+ .iter()
+ .enumerate()
+ .filter(|(i, _)| (*i as f64) > r[0] && (*i as f64) < r[1])
+ .map(|(_, q)| depth(*q))
+ .fold(depth(c.at(r[0])).max(depth(c.at(r[1]))), f64::max),
+ }
+}
+
+/// Distance between the segment `a b` and the box `lo hi` (zero when they meet).
+fn box_gap(a: [f64; 2], b: [f64; 2], lo: [f64; 2], hi: [f64; 2]) -> f64 {
+ let inside = |p: [f64; 2]| p[0] >= lo[0] && p[0] <= hi[0] && p[1] >= lo[1] && p[1] <= hi[1];
+ if inside(a) || inside(b) {
+ return 0.;
+ }
+ let corners = [[lo[0], lo[1]], [hi[0], lo[1]], [hi[0], hi[1]], [lo[0], hi[1]]];
+ let crosses = (0..4).any(|k| {
+ let (Some(c), Some(d)) = (corners.get(k), corners.get((k + 1) % 4)) else { return false };
+ let side = |p: [f64; 2], q: [f64; 2], r: [f64; 2]| (q[0] - p[0]) * (r[1] - p[1]) - (q[1] - p[1]) * (r[0] - p[0]);
+ side(a, b, *c) * side(a, b, *d) <= 0. && side(*c, *d, a) * side(*c, *d, b) <= 0.
+ });
+ if crosses {
+ return 0.;
+ }
+ let to_box = |p: [f64; 2]| {
+ let dx = (lo[0] - p[0]).max(p[0] - hi[0]).max(0.);
+ let dy = (lo[1] - p[1]).max(p[1] - hi[1]).max(0.);
+ dx.hypot(dy)
+ };
+ let corner_gap = corners.iter().map(|q| point_segment(*q, a, b)).fold(f64::MAX, f64::min);
+ to_box(a).min(to_box(b)).min(corner_gap)
+}
+
+fn scene_centre(defs: &[Prepared], scene: &[Placement]) -> Result<Vec3, HlrError> {
+ let (mut lo, mut hi) = (Vec3::new(f64::MAX, f64::MAX, f64::MAX), Vec3::new(f64::MIN, f64::MIN, f64::MIN));
+ for p in scene {
+ if !p.rigid() {
+ return Err(HlrError::Invalid("placement (not a rotation and translation)"));
+ }
+ let def = defs.get(p.body).ok_or(HlrError::Invalid("placement body index"))?;
+ for k in 0..8 {
+ let c = Vec3::new(
+ if k & 1 == 0 { def.lo.x } else { def.hi.x },
+ if k & 2 == 0 { def.lo.y } else { def.hi.y },
+ if k & 4 == 0 { def.lo.z } else { def.hi.z },
+ );
+ let w = p.apply(c + def.offset);
+ if !(w.x.abs() <= MAX_COORDINATE && w.y.abs() <= MAX_COORDINATE && w.z.abs() <= MAX_COORDINATE) {
+ return Err(HlrError::Invalid("scene extent"));
+ }
+ lo = lo.min(w);
+ hi = hi.max(w);
+ }
+ }
+ let c = if scene.is_empty() { Vec3::ZERO } else { (lo + hi) * 0.5 };
+ if c.is_finite() { Ok(c) } else { Err(HlrError::Invalid("scene extent")) }
+}
+
+fn shift_seg(g: Seg2, d: [f64; 2]) -> Seg2 {
+ let m = |v: Vec2| Vec2::new(v.x + d[0], v.y + d[1]);
+ match g {
+ Seg2::Line { a, b } => Seg2::Line { a: m(a), b: m(b) },
+ Seg2::Arc { center, radius, start, sweep } => Seg2::Arc { center: m(center), radius, start, sweep },
+ Seg2::Cubic { p0, p1, p2, p3 } => Seg2::Cubic { p0: m(p0), p1: m(p1), p2: m(p2), p3: m(p3) },
+ Seg2::Conic { a, apex, b, w } => Seg2::Conic { a: m(a), apex: m(apex), b: m(b), w },
+ Seg2::Bezier { n, p } => Seg2::Bezier { n, p: p.map(m) },
+ }
+}
+
+/// A piece's screen geometry: a line for a straight source, exact conic arcs for a circle or
+/// ellipse (an orthographic projection is affine, so it maps them to ellipses exactly), chords
+/// between its exact points otherwise.
+fn piece_geometry(t: &Track, piece: &Piece, p: &Placement, view: &View) -> (Vec<Seg2>, CurveAccuracy) {
+ let c = t.c3();
+ let s = |q: Vec3| {
+ let v = view.screen(p.apply(q));
+ Vec2::new(v[0], v[1])
+ };
+ let chords = || {
+ let segs: Vec<Seg2> =
+ piece.points.windows(2).filter_map(|w| Some(Seg2::Line { a: Vec2::from(*w.first()?), b: Vec2::from(*w.get(1)?) })).collect();
+ (segs, CurveAccuracy::Sampled { max_sample_deviation_mm: piece.sag })
+ };
+ match c {
+ C3::Line { .. } if t.acc == CurveAccuracy::Analytic => {
+ (vec![Seg2::Line { a: s(c.at(piece.t[0])), b: s(c.at(piece.t[1])) }], CurveAccuracy::Analytic)
+ }
+ _ if t.acc == CurveAccuracy::Analytic => {
+ // A circle or ellipse: o + u cos(a) + v sin(a), sampled at the piece's angles.
+ let frame = match c {
+ C3::Arc { o, x, y, r, .. } => Some((*o, *x * r[0], *y * r[1], true)),
+ _ => as_circle(c, 1e-9).and_then(|(centre, normal, r)| {
+ let e1 = (c.at(t.range[0]) - centre).normalized()?;
+ Some((centre, e1 * r, normal.cross(e1) * r, false))
+ }),
+ };
+ let Some((o, u, v, param_is_angle)) = frame else { return chords() };
+ let angle = |x: f64| {
+ if param_is_angle {
+ return x;
+ }
+ let w = c.at(x) - o;
+ w.dot(v).atan2(w.dot(u))
+ };
+ // The angle turned from the piece's start to its end: the way it turns, certified
+ // all along it (C3::turn_sign; a piece that turns back, or one that cannot be
+ // certified, is drawn as chords), and its end angles fix the turn, however unevenly
+ // it is parameterised. A whole closed edge turns a full circle.
+ let (a0, a1) = if param_is_angle {
+ (piece.t[0], piece.t[1])
+ } else {
+ let tau = std::f64::consts::TAU;
+ let wrap = |d: f64| (d + std::f64::consts::PI).rem_euclid(tau) - std::f64::consts::PI;
+ let (t0, t1) = (piece.t[0], piece.t[1]);
+ let span = (t.range[1] - t.range[0]).abs();
+ let a0 = angle(t0);
+ let ends = angle(t1) - a0;
+ let dir = match c.turn_sign([t0, t1], o, u, v) {
+ Some(d) if d != 0. => d,
+ // It does not turn at all: a point-like piece, unless its ends differ.
+ Some(_) if wrap(ends).abs() <= 1e-9 => 1.,
+ _ => return chords(),
+ };
+ let mut turn = (dir * ends).rem_euclid(tau);
+ let whole =
+ t0 <= t.range[0] + 1e-12 * span && t1 >= t.range[1] - 1e-12 * span && c.at(t.range[0]).dist(c.at(t.range[1])) <= 1e-9 * u.len();
+ if whole && (turn < 1e-9 || turn > tau - 1e-9) {
+ turn = tau;
+ }
+ (a0, a0 + dir * turn)
+ };
+ let pieces = ((a1 - a0).abs() / std::f64::consts::FRAC_PI_2).ceil().max(1.) as usize;
+ let at = |a: f64| o + u * a.cos() + v * a.sin();
+ let mut out = Vec::with_capacity(pieces);
+ for k in 0..pieces {
+ let (b0, b1) = (a0 + (a1 - a0) * k as f64 / pieces as f64, a0 + (a1 - a0) * (k + 1) as f64 / pieces as f64);
+ let (m, h) = (0.5 * (b0 + b1), 0.5 * (b1 - b0));
+ let w = h.cos();
+ if w <= 1e-12 {
+ return chords();
+ }
+ out.push(Seg2::Conic { a: s(at(b0)), apex: s(o + (u * m.cos() + v * m.sin()) / w), b: s(at(b1)), w });
+ }
+ (out, CurveAccuracy::Analytic)
+ }
+ _ => chords(),
+ }
+}
+
+/// Finds where projected tracks cross or touch and records the split parameters on both.
+fn crossings(tracks: &mut [Track], ctx: &Ctx) -> Result<usize, HlrError> {
+ struct Seg {
+ track: usize,
+ i: usize,
+ a: [f64; 2],
+ b: [f64; 2],
+ sag: f64,
+ /// The grid cells it was put in: first and last column and row.
+ cells: [usize; 4],
+ }
+ let mut segs = Vec::new();
+ // Where each track's segments start in `segs`.
+ let mut first_seg = Vec::with_capacity(tracks.len());
+ let (mut lo, mut hi) = ([f64::MAX; 2], [f64::MIN; 2]);
+ for (ti, t) in tracks.iter().enumerate() {
+ first_seg.push(segs.len());
+ for (i, w) in t.samples.windows(2).enumerate() {
+ let (Some(a), Some(b)) = (w.first(), w.get(1)) else { continue };
+ for p in [a.1, b.1] {
+ lo = [lo[0].min(p[0]), lo[1].min(p[1])];
+ hi = [hi[0].max(p[0]), hi[1].max(p[1])];
+ }
+ segs.push(Seg { track: ti, i, a: a.1, b: b.1, sag: t.sags.get(i).copied().unwrap_or(0.), cells: [0; 4] });
+ }
+ }
+ if segs.is_empty() {
+ return Ok(0);
+ }
+ let n = ((segs.len() as f64).sqrt().ceil() as usize).clamp(1, 512);
+ let cell = [((hi[0] - lo[0]) / n as f64).max(1e-12), ((hi[1] - lo[1]) / n as f64).max(1e-12)];
+ let idx = |p: [f64; 2]| -> (usize, usize) {
+ (((p[0] - lo[0]) / cell[0]).floor().clamp(0., (n - 1) as f64) as usize, ((p[1] - lo[1]) / cell[1]).floor().clamp(0., (n - 1) as f64) as usize)
+ };
+ let mut grid: Vec<Vec<usize>> = vec![Vec::new(); n * n];
+ let mut entries = 0usize;
+ for (si, s) in segs.iter_mut().enumerate() {
+ if si % 65536 == 0 && (ctx.cancel)() {
+ return Err(HlrError::Cancelled);
+ }
+ let g = s.sag + 1e-9 * ctx.scale;
+ let (a, b) = (idx([s.a[0].min(s.b[0]) - g, s.a[1].min(s.b[1]) - g]), idx([s.a[0].max(s.b[0]) + g, s.a[1].max(s.b[1]) + g]));
+ entries = entries.saturating_add((b.0 - a.0 + 1).saturating_mul(b.1 - a.1 + 1));
+ if entries > 50_000_000 {
+ return Err(HlrError::Budget("crossing grid"));
+ }
+ s.cells = [a.0, a.1, b.0, b.1];
+ for y in a.1..=b.1 {
+ for x in a.0..=b.0 {
+ if let Some(c) = grid.get_mut(y * n + x) {
+ c.push(si);
+ }
+ }
+ }
+ }
+ // A pair of segments is visited once per cell they share, so the number of visits is
+ // known before the search starts, and no set of pairs already met has to be kept.
+ let pairs = grid.iter().fold(0usize, |n, c| n.saturating_add(c.len().saturating_mul(c.len().saturating_sub(1)) / 2));
+ if pairs > 500_000_000 {
+ return Err(HlrError::Budget("crossing pair"));
+ }
+ let tol = 1e-9 * ctx.scale;
+ let mut found = Vec::new();
+ let mut visits = 0usize;
+ // Two chords that lie on each other end to end, to rounding.
+ let coincide = |s: &Seg, t: &Seg| {
+ [point_segment(s.a, t.a, t.b), point_segment(s.b, t.a, t.b), point_segment(t.a, s.a, s.b), point_segment(t.b, s.a, s.b)]
+ .iter()
+ .all(|d| *d <= tol)
+ };
+ // The segment of the same track on the other side of a segment's end `f` (0 or 1).
+ let across = |s: &Seg, f: f64| -> Option<&Seg> {
+ let i = if f == 1. { s.i + 1 } else { s.i.checked_sub(1)? };
+ segs.get(first_seg.get(s.track)? + i).filter(|n| n.track == s.track && n.i == i)
+ };
+ // Two curves that coincide meet at every sample point they share, chord ends touching. Such
+ // a meeting is no crossing when the curves also coincide on both sides of it; where a
+ // coincident run starts or ends, one side differs and the meeting is kept.
+ // The end (0 or 1) of a segment that fraction `f` along it lies at, to rounding.
+ let end_at = |s: &Seg, f: f64| {
+ let len = (s.b[0] - s.a[0]).hypot(s.b[1] - s.a[1]);
+ if f * len <= tol {
+ Some(0.)
+ } else if (1. - f) * len <= tol {
+ Some(1.)
+ } else {
+ None
+ }
+ };
+ let shared_point = |s: &Seg, t: &Seg, (u, v): (f64, f64)| {
+ end_at(s, u)
+ .zip(end_at(t, v))
+ .and_then(|(fu, fv)| across(s, fu).zip(across(t, fv)))
+ .is_some_and(|(s2, t2)| coincide(s, t2) && coincide(s2, t))
+ };
+ // Screen points of a segment's exact curve, `k` pieces (one for lines and polylines).
+ let sub = |track: usize, i: usize, k: usize| -> Vec<[f64; 2]> {
+ let Some(tr) = tracks.get(track) else { return Vec::new() };
+ let (Some(a), Some(b)) = (tr.samples.get(i), tr.samples.get(i + 1)) else { return Vec::new() };
+ let Some(p) = ctx.scene.get(tr.placement) else { return Vec::new() };
+ let k = if matches!(tr.c3(), C3::Line { .. } | C3::Polyline(_)) { 1 } else { k };
+ (0..=k).map(|j| ctx.view.screen(p.apply(tr.c3().at(a.0 + (b.0 - a.0) * j as f64 / k as f64)))).collect()
+ };
+ for (c, cellv) in grid.iter().enumerate() {
+ let (x, y) = (c % n, c / n);
+ for (k, &i) in cellv.iter().enumerate() {
+ for &j in cellv.iter().skip(k + 1) {
+ visits += 1;
+ if visits.is_multiple_of(65536) && (ctx.cancel)() {
+ return Err(HlrError::Cancelled);
+ }
+ let (Some(s), Some(t)) = (segs.get(i), segs.get(j)) else { continue };
+ // A pair sharing several cells is intersected in the first of them only.
+ if s.cells[0].max(t.cells[0]) != x || s.cells[1].max(t.cells[1]) != y {
+ continue;
+ }
+ if s.track == t.track && s.i.abs_diff(t.i) <= 1 {
+ continue;
+ }
+ let straight = |k: usize| tracks.get(k).is_some_and(|tr| matches!(tr.c3(), C3::Line { .. }));
+ let overlaps = straight(s.track) && straight(t.track);
+ let hits = seg_hits(s.a, s.b, t.a, t.b, tol, overlaps);
+ let reach = s.sag + t.sag + tol;
+ // Chords of two curves that lie on each other end to end, to rounding (one curve
+ // projected again, aligned holes seen along their axes), cross only within that
+ // rounding, everywhere and nowhere in particular: visibility changes where such a
+ // run starts or ends, which chords that only partly overlap find. Intersecting
+ // their fine pieces is wasted work. Chords merely within each other's sag are not
+ // skipped: the curves between them can still cross.
+ let coincident = s.track != t.track && s.sag + t.sag > 0. && coincide(s, t);
+ if coincident {
+ continue;
+ }
+ if hits.is_empty() && s.sag + t.sag > 0. && seg_gap(s.a, s.b, t.a, t.b) <= reach {
+ // The chords miss but the curves may not: two crossings close together can
+ // lie within one chord's sag. Intersect finer pieces of the exact curves.
+ let (ps, pt) = (sub(s.track, s.i, 16), sub(t.track, t.i, 16));
+ let (ns, nt) = (ps.len().saturating_sub(1).max(1) as f64, pt.len().saturating_sub(1).max(1) as f64);
+ for (x, w) in ps.windows(2).enumerate() {
+ for (y, z) in pt.windows(2).enumerate() {
+ let (Some(a), Some(b), Some(c), Some(d)) = (w.first(), w.get(1), z.first(), z.get(1)) else { continue };
+ for (u, v) in seg_hits(*a, *b, *c, *d, tol, false) {
+ found.push((s.track, s.i, (x as f64 + u) / ns, t.track, t.i, (y as f64 + v) / nt));
+ }
+ }
+ }
+ } else {
+ let curved = s.track != t.track && s.sag + t.sag > 0.;
+ for (u, v) in hits {
+ if !(curved && shared_point(s, t, (u, v))) {
+ found.push((s.track, s.i, u, t.track, t.i, v));
+ }
+ }
+ }
+ if found.len() > 50_000_000 {
+ return Err(HlrError::Budget("crossing"));
+ }
+ }
+ }
+ }
+ // Curves that nearly coincide in projection (two fitted copies of one intersection, say)
+ // cross each other again and again within their tolerance; visibility changes only where
+ // the coincidence starts or ends, so such a pair keeps only its outermost crossings.
+ let mut by_pair: std::collections::BTreeMap<(usize, usize), Vec<(usize, usize, f64, usize, usize, f64)>> = std::collections::BTreeMap::new();
+ for c in found {
+ by_pair.entry((c.0.min(c.3), c.0.max(c.3))).or_default().push(c);
+ }
+ let mut found = Vec::new();
+ for (_, mut list) in by_pair {
+ if list.len() > 8 {
+ list.sort_by(|a, b| (a.1 as f64 + a.2).total_cmp(&(b.1 as f64 + b.2)));
+ // Collapse only when the curves stay within their sag of each other between every
+ // pair of consecutive crossings (one curve seen twice); a curve that weaves across
+ // another keeps all its crossings.
+ let together = list.windows(2).all(|w| {
+ let (Some(x), Some(y)) = (w.first(), w.get(1)) else { return false };
+ let (Some(ta), Some(tb)) = (tracks.get(x.0), tracks.get(x.3)) else { return false };
+ let mid = 0.5 * (sample_param(tracks, x.0, x.1, x.2) + sample_param(tracks, y.0, y.1, y.2));
+ let Some(pa) = ctx.scene.get(ta.placement) else { return false };
+ let q = ctx.view.screen(pa.apply(ta.c3().at(mid)));
+ let sag = |t: &Track| t.sags.iter().fold(0., |m: f64, v| m.max(*v));
+ let reach = 4. * (sag(ta) + sag(tb)) + tol;
+ // Only the other curve's chords between its two crossings (and one either side).
+ let (j0, j1) = (x.4.min(y.4).saturating_sub(1), x.4.max(y.4) + 2);
+ tb.samples.get(j0..j1.min(tb.samples.len())).is_some_and(|run| {
+ run.windows(2).any(|w| match (w.first(), w.get(1)) {
+ (Some(a), Some(b)) => point_segment(q, a.1, b.1) <= reach,
+ _ => false,
+ })
+ })
+ });
+ if together {
+ let (Some(first), Some(last)) = (list.first().copied(), list.last().copied()) else { continue };
+ list = vec![first, last];
+ }
+ }
+ found.extend(list);
+ }
+ let count = found.len();
+ for (ta, ia, u, tb, ib, v) in found {
+ let pa = sample_param(tracks, ta, ia, u);
+ let pb = sample_param(tracks, tb, ib, v);
+ let (pa, pb) = refine(tracks, ctx, ta, pa, tb, pb);
+ if let Some(t) = tracks.get_mut(ta) {
+ t.splits.push(pa);
+ }
+ if let Some(t) = tracks.get_mut(tb) {
+ t.splits.push(pb);
+ }
+ }
+ Ok(count)
+}
+
+fn sample_param(tracks: &[Track], t: usize, i: usize, f: f64) -> f64 {
+ let Some(tr) = tracks.get(t) else { return 0. };
+ match (tr.samples.get(i), tr.samples.get(i + 1)) {
+ (Some(a), Some(b)) => a.0 + (b.0 - a.0) * f,
+ _ => tr.range[0],
+ }
+}
+
+/// Newton refinement of a crossing on the exact projected curves; keeps the linear estimate
+/// when the curves are tangent or the iteration leaves the curves' ranges.
+fn refine(tracks: &[Track], ctx: &Ctx, ta: usize, sa: f64, tb: usize, sb: f64) -> (f64, f64) {
+ let (Some(a), Some(b)) = (tracks.get(ta), tracks.get(tb)) else { return (sa, sb) };
+ let (Some(pa), Some(pb)) = (ctx.scene.get(a.placement), ctx.scene.get(b.placement)) else { return (sa, sb) };
+ if matches!(a.c3(), C3::Polyline(_)) || matches!(b.c3(), C3::Polyline(_)) {
+ return (sa, sb);
+ }
+ let fa = |s: f64| ctx.view.screen(pa.apply(a.c3().at(s)));
+ let fb = |s: f64| ctx.view.screen(pb.apply(b.c3().at(s)));
+ let da = |s: f64| ctx.view.screen(pa.apply(a.c3().d1(s)) - pa.translation);
+ let db = |s: f64| ctx.view.screen(pb.apply(b.c3().d1(s)) - pb.translation);
+ let (mut s, mut t) = (sa, sb);
+ for _ in 0..30 {
+ let (p, q) = (fa(s), fb(t));
+ let f = [p[0] - q[0], p[1] - q[1]];
+ let (ja, jb) = (da(s), db(t));
+ // [ja, -jb] [ds, dt]^T = -f
+ let det = ja[0] * (-jb[1]) - (-jb[0]) * ja[1];
+ if det.abs() <= 1e-14 * (1. + ja[0].abs() + ja[1].abs()) * (1. + jb[0].abs() + jb[1].abs()) {
+ return (sa, sb);
+ }
+ let ds = (-f[0] * (-jb[1]) - (-jb[0]) * (-f[1])) / det;
+ let dt = (ja[0] * (-f[1]) - (-f[0]) * ja[1]) / det;
+ s += ds;
+ t += dt;
+ if ds.abs() + dt.abs() <= 1e-15 * (1. + s.abs() + t.abs()) {
+ break;
+ }
+ }
+ let ok = |x: f64, r: [f64; 2]| x.is_finite() && x >= r[0] - 1e-12 * (r[1] - r[0]) && x <= r[1] + 1e-12 * (r[1] - r[0]);
+ let close = (s - sa).abs() <= 0.5 * (a.range[1] - a.range[0]) && (t - sb).abs() <= 0.5 * (b.range[1] - b.range[0]);
+ if ok(s, a.range) && ok(t, b.range) && close { (s.clamp(a.range[0], a.range[1]), t.clamp(b.range[0], b.range[1])) } else { (sa, sb) }
+}
+
+/// Marks hidden and uncertain pieces lying within `tol` of a visible piece of another line.
+fn cover(lines: &mut [Line], tol: f64, step: f64, cancel: &dyn Fn() -> bool) -> Result<(), HlrError> {
+ // Chords of visible and hidden pieces, keyed by (line, piece) so a piece never covers
+ // itself; another piece of the same line may (a circle seen edge-on folds over itself).
+ // `tol` is the base; each chord adds its own sag, each query point the sag of its chord.
+ let mut segs: Vec<((usize, usize), Visibility, [f64; 2], [f64; 2], f64)> = Vec::new();
+ for (li, l) in lines.iter().enumerate() {
+ for (pi, p) in l.pieces.iter().enumerate().filter(|(_, p)| p.visibility != Visibility::Uncertain) {
+ segs.extend(p.points.windows(2).filter_map(|w| Some(((li, pi), p.visibility, *w.first()?, *w.get(1)?, p.sag))));
+ }
+ }
+ let reach = segs.iter().map(|s| s.4).fold(0., f64::max) * 2. + tol;
+ if segs.is_empty() {
+ return Ok(());
+ }
+ // Bucket the chords on a grid of cells at least `tol` wide.
+ let (mut lo, mut hi) = ([f64::MAX; 2], [f64::MIN; 2]);
+ for (_, _, a, b, _) in &segs {
+ for p in [a, b] {
+ lo = [lo[0].min(p[0]), lo[1].min(p[1])];
+ hi = [hi[0].max(p[0]), hi[1].max(p[1])];
+ }
+ }
+ let n = ((segs.len() as f64).sqrt().ceil() as usize).clamp(1, 1024);
+ let cell = [((hi[0] - lo[0]) / n as f64).max(reach), ((hi[1] - lo[1]) / n as f64).max(reach)];
+ let at = |x: f64, k: usize| (((x - lo[k]) / cell[k]).floor().max(0.) as usize).min(n - 1);
+ let mut grid: Vec<Vec<usize>> = vec![Vec::new(); n * n];
+ for (i, (_, _, a, b, _)) in segs.iter().enumerate() {
+ for y in at(a[1].min(b[1]) - reach, 1)..=at(a[1].max(b[1]) + reach, 1) {
+ for x in at(a[0].min(b[0]) - reach, 0)..=at(a[0].max(b[0]) + reach, 0) {
+ if let Some(c) = grid.get_mut(y * n + x) {
+ c.push(i);
+ }
+ }
+ }
+ }
+ // Which coincident pieces hide a piece: visible ones hide hidden and uncertain pieces;
+ // a duplicate of a visible or hidden piece on an earlier line is dropped.
+ let hides = |key: (usize, usize), own: Visibility, other: (usize, usize), state: Visibility| {
+ other != key
+ && match (own, state) {
+ (Visibility::Hidden | Visibility::Uncertain, Visibility::Visible) => true,
+ (Visibility::Visible, Visibility::Visible) | (Visibility::Hidden, Visibility::Hidden) => other.0 < key.0,
+ _ => false,
+ }
+ };
+ let checks = std::cell::Cell::new(0usize);
+ let near = |key: (usize, usize), own: Visibility, q: [f64; 2], slack: f64| {
+ checks.set(checks.get() + 1);
+ let Some(bucket) = grid.get(at(q[1], 1) * n + at(q[0], 0)) else { return false };
+ bucket
+ .iter()
+ .filter_map(|i| segs.get(*i))
+ .any(|(k, state, a, b, sag)| hides(key, own, *k, *state) && point_segment(q, *a, *b) <= tol + sag + slack)
+ };
+ for (li, l) in lines.iter_mut().enumerate() {
+ for (pi, p) in l.pieces.iter_mut().enumerate() {
+ // Points along every chord at most `step` apart (a coincident line may cover a long
+ // chord's ends and middle yet leave gaps between them). Points between the exact
+ // ones lie on the chord, up to the piece's sag from its curve.
+ let mut covered = !p.points.is_empty();
+ if checks.get() > 200_000_000 {
+ return Err(HlrError::Budget("coverage"));
+ }
+ if pi % 16 == 0 && cancel() {
+ return Err(HlrError::Cancelled);
+ }
+ for w in p.points.windows(2) {
+ let (Some(a), Some(b)) = (w.first(), w.get(1)) else { continue };
+ let k = ((a[0] - b[0]).hypot(a[1] - b[1]) / step).ceil().clamp(1., 1e6) as usize;
+ covered = covered
+ && (0..=k).all(|j| {
+ let f = j as f64 / k as f64;
+ // The piece's own representation error (chord sag, fitted bound) applies
+ // to every point it is checked at.
+ let slack = p.sag;
+ near((li, pi), p.visibility, [a[0] + (b[0] - a[0]) * f, a[1] + (b[1] - a[1]) * f], slack)
+ });
+ if !covered {
+ break;
+ }
+ }
+ if let [q] = p.points.as_slice() {
+ covered = near((li, pi), p.visibility, *q, p.sag);
+ }
+ p.covered = covered;
+ }
+ }
+ Ok(())
+}
+
+fn point_segment(q: [f64; 2], a: [f64; 2], b: [f64; 2]) -> f64 {
+ let (ex, ey) = (b[0] - a[0], b[1] - a[1]);
+ let l2 = ex * ex + ey * ey;
+ let t = if l2 > 0. { (((q[0] - a[0]) * ex + (q[1] - a[1]) * ey) / l2).clamp(0., 1.) } else { 0. };
+ (a[0] + t * ex - q[0]).hypot(a[1] + t * ey - q[1])
+}
+
+/// Smallest distance between two screen segments that do not cross.
+fn seg_gap(a: [f64; 2], b: [f64; 2], c: [f64; 2], d: [f64; 2]) -> f64 {
+ point_segment(a, c, d).min(point_segment(b, c, d)).min(point_segment(c, a, b)).min(point_segment(d, a, b))
+}
+
+/// Intersections of two screen segments, touching included: fractions along each.
+fn seg_hits(a: [f64; 2], b: [f64; 2], c: [f64; 2], d: [f64; 2], tol: f64, overlaps: bool) -> Vec<(f64, f64)> {
+ let r = [b[0] - a[0], b[1] - a[1]];
+ let s = [d[0] - c[0], d[1] - c[1]];
+ let den = r[0] * s[1] - r[1] * s[0];
+ let w = [c[0] - a[0], c[1] - a[1]];
+ let (rl, sl) = ((r[0] * r[0] + r[1] * r[1]).sqrt(), (s[0] * s[0] + s[1] * s[1]).sqrt());
+ if rl <= 0. || sl <= 0. {
+ return Vec::new();
+ }
+ if den.abs() > 1e-12 * rl * sl {
+ let u = (w[0] * s[1] - w[1] * s[0]) / den;
+ let v = (w[0] * r[1] - w[1] * r[0]) / den;
+ let (tu, tv) = (tol / rl, tol / sl);
+ if u >= -tu && u <= 1. + tu && v >= -tv && v <= 1. + tv {
+ return vec![(u.clamp(0., 1.), v.clamp(0., 1.))];
+ }
+ return Vec::new();
+ }
+ // Parallel: overlapping collinear lines split at each other's endpoints. Sampled curves
+ // that coincide are skipped: their chords overlap everywhere and would split at every sample.
+ let dist = (w[0] * r[1] - w[1] * r[0]).abs() / rl;
+ if dist > tol || !overlaps {
+ return Vec::new();
+ }
+ let along = |p: [f64; 2]| ((p[0] - a[0]) * r[0] + (p[1] - a[1]) * r[1]) / (rl * rl);
+ let back = |p: [f64; 2]| ((p[0] - c[0]) * s[0] + (p[1] - c[1]) * s[1]) / (sl * sl);
+ let mut out = Vec::new();
+ for (p, on_cd) in [(c, true), (d, true), (a, false), (b, false)] {
+ let (u, v) = if on_cd { (along(p), if p == c { 0. } else { 1. }) } else { (if p == a { 0. } else { 1. }, back(p)) };
+ if (0. ..=1.).contains(&u) && (0. ..=1.).contains(&v) {
+ out.push((u, v));
+ }
+ }
+ out
+}
+
+/// States at a few interior points, with transitions located by bisection.
+fn classify_range(t: &Track, a: f64, b: f64, ctx: &Ctx) -> Result<Vec<([f64; 2], Visibility)>, HlrError> {
+ let fr = [0.1, 0.3, 0.5, 0.7, 0.9];
+ let xs: Vec<f64> = fr.iter().map(|f| a + (b - a) * f).collect();
+ let mut states = Vec::with_capacity(xs.len());
+ for x in &xs {
+ states.push(classify(t, *x, ctx)?);
+ }
+ let mut out: Vec<([f64; 2], Visibility)> = Vec::new();
+ let mut start = a;
+ for k in 0..xs.len() {
+ let (Some(&s), Some(&x)) = (states.get(k), xs.get(k)) else { continue };
+ if let (Some(&next), Some(&nx)) = (states.get(k + 1), xs.get(k + 1)) {
+ if next != s {
+ ctx.transitions.set(ctx.transitions.get() + 1);
+ let (mut lo, mut hi) = (x, nx);
+ for _ in 0..40 {
+ let mid = 0.5 * (lo + hi);
+ if classify(t, mid, ctx)? == s {
+ lo = mid;
+ } else {
+ hi = mid;
+ }
+ }
+ let cut = 0.5 * (lo + hi);
+ out.push(([start, cut], s));
+ start = cut;
+ }
+ } else {
+ out.push(([start, b], s));
+ }
+ let _ = x;
+ }
+ Ok(out)
+}
+
+fn classify(t: &Track, x: f64, ctx: &Ctx) -> Result<Visibility, HlrError> {
+ let n = ctx.rays.get() + 1;
+ ctx.rays.set(n);
+ if n > ctx.max_rays {
+ return Err(HlrError::Budget("ray"));
+ }
+ if n.is_multiple_of(1024) && (ctx.cancel)() {
+ return Err(HlrError::Cancelled);
+ }
+ let own = ctx.scene.get(t.placement).ok_or(HlrError::Invalid("placement"))?;
+ Ok(classify_point(ctx, t.placement, &t.own, t.own_eps, own.apply(t.c3().at(x))))
+}
+
+/// Visibility of a world point on placement `placement` lying on its faces `own`.
+fn classify_point(ctx: &Ctx, placement: usize, own: &[usize], own_eps: f64, world: Vec3) -> Visibility {
+ let screen = ctx.view.screen(world);
+ let depth = world.dot(ctx.view.d);
+ let toward = -ctx.view.d;
+ let mut uncertain = false;
+ let mut hits: Vec<Hit> = Vec::new();
+ for (qi, q) in ctx.scene.iter().enumerate() {
+ let Some((slo, shi, dmin)) = ctx.boxes.get(qi) else { continue };
+ let pad = ctx.eps_other;
+ if screen[0] < slo[0] - pad || screen[0] > shi[0] + pad || screen[1] < slo[1] - pad || screen[1] > shi[1] + pad || *dmin > depth {
+ continue;
+ }
+ let Some(def) = ctx.defs.get(q.body) else { continue };
+ let (p0, dl) = (q.local(world), q.local_dir(toward));
+ for (fi, f) in def.faces.iter().enumerate() {
+ let is_own = qi == placement && own.contains(&fi);
+ let Some([l0, l1]) = slab(p0, dl, f.lo, f.hi) else { continue };
+ let eps = if is_own { own_eps } else { ctx.eps_other };
+ let range = [l0.max(eps), l1];
+ if !(range[1] >= range[0]) {
+ continue;
+ }
+ ctx.surface_tests.set(ctx.surface_tests.get() + 1);
+ hits.clear();
+ f.surface.ray_as(&f.analytic, p0, dl, range, &mut hits);
+ for h in &hits {
+ let p = f.surface.point(h.uv);
+ let tol = 2. * f.trim.chord_error + 1e-7 * (f.hi - f.lo).len();
+ // A hit on the boundary is uncertain on either side of it, so the parity test is
+ // left out there: its cost grows with the boundary around the hit, all of a
+ // circle when bodies in line along the view meet each other on their circles.
+ if f.trim.near(p, tol) {
+ uncertain = true;
+ continue;
+ }
+ match f.trim.contains(h.uv) {
+ None => uncertain = true,
+ Some(inside) => {
+ // An unsupported freeform face never hides anything for certain.
+ let unsure = f.freeform && !ctx.freeform;
+ if inside && (unsure || h.grazing || (!is_own && h.lam < ctx.eps_own)) {
+ uncertain = true;
+ } else if inside {
+ return Visibility::Hidden;
+ }
+ }
+ }
+ }
+ }
+ }
+ if uncertain { Visibility::Uncertain } else { Visibility::Visible }
+}
+
+/// Phase timing where a clock exists.
+struct Clock {
+ #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+ last: std::cell::Cell<std::time::Instant>,
+}
+
+impl Clock {
+ fn start() -> Clock {
+ Clock {
+ #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+ last: std::cell::Cell::new(std::time::Instant::now()),
+ }
+ }
+ fn lap(&self) -> f64 {
+ #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+ {
+ let now = std::time::Instant::now();
+ let ms = now.duration_since(self.last.get()).as_secs_f64() * 1e3;
+ self.last.set(now);
+ ms
+ }
+ #[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
+ 0.
+ }
+}
+
+/// Ray parameter range inside an axis-aligned box.
+fn slab(p: Vec3, d: Vec3, lo: Vec3, hi: Vec3) -> Option<[f64; 2]> {
+ let (mut t0, mut t1) = (f64::NEG_INFINITY, f64::INFINITY);
+ for (o, dd, a, b) in [(p.x, d.x, lo.x, hi.x), (p.y, d.y, lo.y, hi.y), (p.z, d.z, lo.z, hi.z)] {
+ if dd.abs() < 1e-300 {
+ if o < a || o > b {
+ return None;
+ }
+ } else {
+ let (x, y) = ((a - o) / dd, (b - o) / dd);
+ t0 = t0.max(x.min(y));
+ t1 = t1.min(x.max(y));
+ }
+ }
+ (t1 >= t0.max(0.)).then_some([t0.max(0.), t1])
+}
+
+#[cfg(test)]
+#[path = "../hlr_tests.rs"]
+mod tests;
diff --git a/crates/geom/src/hlr/silhouette.rs b/crates/geom/src/hlr/silhouette.rs
new file mode 100644
index 0000000000..af14e13323
--- /dev/null
+++ b/crates/geom/src/hlr/silhouette.rs
@@ -0,0 +1,347 @@
+//! Silhouettes of curved faces: the curves where the surface normal is perpendicular to the
+//! direction of sight. Recognised cylinders and cones give exact lines and spheres an exact
+//! circle; other surfaces are contoured on a chart grid, each point refined onto the curve,
+//! and the deviation of the chords from the curve is measured.
+
+use super::curve::C3;
+use super::surface::{Analytic, S3};
+use super::trim::Trim;
+use crate::Vec3;
+use crate::section::CurveAccuracy;
+
+const TAU: f64 = std::f64::consts::TAU;
+
+pub(crate) struct Sil {
+ pub curve: C3,
+ pub acc: CurveAccuracy,
+ /// Parameter ranges of `curve` that lie inside the face.
+ pub ranges: Vec<[f64; 2]>,
+}
+
+fn perp(a: Vec3) -> Vec3 {
+ a.any_perp().normalized().unwrap_or(Vec3::new(1., 0., 0.))
+}
+
+/// Axial extent of the faces' boundaries relative to `p` along `a`.
+fn extent(parts: &[(&S3, &Trim)], p: Vec3, a: Vec3) -> (f64, f64) {
+ parts.iter().flat_map(|(_, trim)| trim.chords.iter()).flat_map(|(x, y)| [*x, *y]).fold((f64::MAX, f64::MIN), |(lo, hi), q| {
+ let t = (q - p).dot(a);
+ (lo.min(t), hi.max(t))
+ })
+}
+
+/// Silhouettes of a set of faces on one surface (`parts`: each face's chart and trim, all
+/// recognised as `an`): traced once and kept where they lie on any of the faces, so a
+/// silhouette along a seam between them is one curve.
+pub(crate) fn silhouettes(parts: &[(&S3, &Trim)], an: Analytic, d: Vec3, out: &mut Vec<Sil>) {
+ let Some(&(s, trim)) = parts.first() else { return };
+ let mut push = |curve: C3, acc: CurveAccuracy| {
+ // A traced curve's chords stand up to their deviation off the surface.
+ let slack = match acc {
+ CurveAccuracy::Sampled { max_sample_deviation_mm: dev } => dev,
+ _ => 0.,
+ };
+ let mut ranges: Vec<[f64; 2]> = parts.iter().flat_map(|(s, trim)| inside_ranges(&curve, s, trim, slack)).collect();
+ ranges.sort_by(|a, b| a[0].total_cmp(&b[0]));
+ let [t0, t1] = curve.domain();
+ let mut merged: Vec<[f64; 2]> = Vec::with_capacity(ranges.len());
+ for r in ranges {
+ match merged.last_mut() {
+ Some(last) if r[0] <= last[1] + 1e-12 * (t1 - t0) => last[1] = last[1].max(r[1]),
+ _ => merged.push(r),
+ }
+ }
+ if !merged.is_empty() {
+ out.push(Sil { curve, acc, ranges: merged });
+ }
+ };
+ match an {
+ Analytic::Plane => {}
+ Analytic::Cylinder { p, a, r } => {
+ let Some(m) = a.cross(d).normalized() else { return };
+ let (t0, t1) = extent(parts, p, a);
+ if !(t1 > t0) {
+ return;
+ }
+ for side in [1., -1.] {
+ let base = p + m * (r * side);
+ push(C3::Line { a: base + a * t0, b: base + a * t1 }, CurveAccuracy::Analytic);
+ }
+ }
+ Analytic::Cone { apex, a, half } => {
+ let e1 = perp(a);
+ let e2 = a.cross(e1);
+ let (da, d1, d2) = (d.dot(a), d.dot(e1), d.dot(e2));
+ let rho = (d1 * d1 + d2 * d2).sqrt();
+ if rho <= 1e-12 {
+ return;
+ }
+ let c = half.tan() * da / rho;
+ if c.abs() > 1. {
+ return;
+ }
+ let phid = d2.atan2(d1);
+ let (h0, h1) = extent(parts, apex, a);
+ let (t0, t1) = (h0.max(0.) / half.cos(), h1.max(0.) / half.cos());
+ if !(t1 > t0) {
+ return;
+ }
+ for sign in [1., -1.] {
+ let phi = phid + sign * c.acos();
+ let g = a * half.cos() + (e1 * phi.cos() + e2 * phi.sin()) * half.sin();
+ push(C3::Line { a: apex + g * t0, b: apex + g * t1 }, CurveAccuracy::Analytic);
+ }
+ }
+ Analytic::Sphere { c, r } => {
+ let x = perp(d);
+ let y = d.cross(x);
+ push(C3::Arc { o: c, x, y, r: [r, r], range: [0., TAU] }, CurveAccuracy::Analytic);
+ }
+ Analytic::Torus { .. } | Analytic::Other => {
+ // Several faces of one torus may each hold part of its silhouette: trace it on the
+ // whole torus then. One face keeps its own chart (finer along a narrow strip).
+ let whole = if parts.len() > 1 { S3::from_analytic(&an, [0., 0.], Vec3::ZERO) } else { None };
+ let s = whole.as_ref().unwrap_or(s);
+ let traced = if matches!(s, S3::Rev(_)) { s.rev_silhouette(d) } else { contour(s, trim, d) };
+ for (curve, dev) in traced {
+ let acc = if dev == 0. && matches!(curve, C3::Arc { .. }) {
+ CurveAccuracy::Analytic
+ } else {
+ CurveAccuracy::Sampled { max_sample_deviation_mm: dev }
+ };
+ push(curve, acc);
+ }
+ }
+ }
+}
+
+/// How far a face's surface may lie from the surface its silhouette set is traced on: rounding,
+/// 1e-13 of the face's boundary size plus its coordinates (faces join a set when their
+/// recognised surfaces agree to 1e-13). Only that close does a ray along the set's silhouette
+/// leave the face within the own-face margin (1e-6 of the size): a surface `e` away is crossed
+/// about `sqrt(2 R e)` along the ray.
+pub(crate) fn join_tol(trim: &Trim) -> f64 {
+ 1e-13 * (1. + (trim.hi - trim.lo).len()) + 1e-15 * trim.lo.len().max(trim.hi.len())
+}
+
+/// Parameter ranges of `c` whose points are inside the face, transitions found by bisection.
+/// `slack` is how far the curve itself may stand off the surface (a traced curve's chords).
+pub(crate) fn inside_ranges(c: &C3, s: &S3, trim: &Trim, slack: f64) -> Vec<[f64; 2]> {
+ let [t0, t1] = c.domain();
+ let n = 256;
+ let mut hint = None;
+ // The face is closed: a silhouette along its boundary (a seam between two faces of one
+ // surface, which is not drawn as an edge) is inside. Off the patch is outside: the inversion
+ // clamps to the chart's domain.
+ let tol = 2. * trim.chord_error + 1e-9 * (1. + (trim.hi - trim.lo).len());
+ let on_patch = tol + 2. * join_tol(trim) + 2. * slack;
+ let state = |t: f64, hint: &mut Option<[f64; 2]>| -> bool {
+ let p = c.at(t);
+ let uv = s.inverse(p, *hint);
+ *hint = uv;
+ let Some(uv) = uv else { return false };
+ match trim.contains(uv) {
+ _ if s.point(uv).dist(p) > on_patch => false,
+ Some(true) => true,
+ Some(false) => trim.near(p, tol),
+ None => false,
+ }
+ };
+ // Uniform samples, plus the parameters nearest to the face's boundary points: an in-face
+ // interval is bounded by boundary crossings, so a narrow one between two uniform samples
+ // still gets samples on both of its sides.
+ let mut ts: Vec<f64> = (0..=n).map(|i| t0 + (t1 - t0) * i as f64 / n as f64).collect();
+ let near = 0.02 * (trim.hi - trim.lo).len();
+ ts.extend(trim.chords.iter().step_by(4).filter_map(|(q, _)| closest_param(c, *q).filter(|t| c.at(*t).dist(*q) <= near)));
+ ts.retain(|t| *t >= t0 && *t <= t1);
+ ts.sort_by(f64::total_cmp);
+ ts.dedup_by(|a, b| (*a - *b).abs() <= 1e-12 * (t1 - t0));
+ let mut hints = Vec::with_capacity(ts.len());
+ let states: Vec<bool> = ts
+ .iter()
+ .map(|t| {
+ let st = state(*t, &mut hint);
+ hints.push(hint);
+ st
+ })
+ .collect();
+ let mut out = Vec::new();
+ let mut start: Option<f64> = None;
+ for i in 0..ts.len() {
+ let (Some(&t), Some(&inside)) = (ts.get(i), states.get(i)) else { continue };
+ let prev = i.checked_sub(1).and_then(|j| states.get(j).copied());
+ if prev.is_some_and(|p| p != inside) {
+ let (mut lo, mut hi) = (ts.get(i - 1).copied().unwrap_or(t), t);
+ let near = hints.get(i).copied().flatten();
+ for _ in 0..50 {
+ let mid = 0.5 * (lo + hi);
+ let mut h = near;
+ if state(mid, &mut h) == inside {
+ hi = mid;
+ } else {
+ lo = mid;
+ }
+ }
+ let edge = 0.5 * (lo + hi);
+ if inside {
+ start = Some(edge);
+ } else if let Some(s0) = start.take() {
+ out.push([s0, edge]);
+ }
+ } else if i == 0 && inside {
+ start = Some(t);
+ }
+ }
+ if let Some(s0) = start {
+ out.push([s0, t1]);
+ }
+ out.retain(|r| r[1] - r[0] > 1e-12 * (t1 - t0));
+ out
+}
+
+/// The parameter of the point of `c` nearest to `p` (lines and arcs exactly, polylines at a
+/// vertex), when `p` projects inside the curve's domain.
+fn closest_param(c: &C3, p: Vec3) -> Option<f64> {
+ match c {
+ C3::Line { a, b } => {
+ let e = *b - *a;
+ let l2 = e.len2();
+ (l2 > 0.).then(|| ((p - *a).dot(e) / l2).clamp(0., 1.))
+ }
+ C3::Arc { o, x, y, r, range } => {
+ let w = p - *o;
+ let t = (w.dot(*y) / r[1]).atan2(w.dot(*x) / r[0]);
+ // The turn of t that falls in the range, if any.
+ let k = ((range[0] - t) / TAU).ceil();
+ let t = t + k * TAU;
+ (t <= range[1]).then_some(t)
+ }
+ // The nearest point on any chord, not just the nearest vertex: a face narrower than
+ // the chords still gets parameters inside it.
+ C3::Polyline(pts) => pts
+ .windows(2)
+ .enumerate()
+ .filter_map(|(i, w)| {
+ let (a, b) = (*w.first()?, *w.get(1)?);
+ let e = b - a;
+ let f = if e.len2() > 0. { ((p - a).dot(e) / e.len2()).clamp(0., 1.) } else { 0. };
+ Some((i as f64 + f, (a + e * f).dist(p)))
+ })
+ .min_by(|x, y| x.1.total_cmp(&y.1))
+ .map(|(t, _)| t),
+ C3::Spline { .. } => None,
+ }
+}
+
+/// Zero set of `normal . d` on a chart grid over the face's chart box.
+fn contour(s: &S3, trim: &Trim, d: Vec3) -> Vec<(C3, f64)> {
+ let Some((lo, hi)) = trim.uv_bounds() else { return Vec::new() };
+ let dom = s.domain();
+ let lo = [lo[0].max(dom[0][0]), lo[1].max(dom[1][0])];
+ let hi = [hi[0].min(dom[0][1]), hi[1].min(dom[1][1])];
+ if !(hi[0] > lo[0] && hi[1] > lo[1]) {
+ return Vec::new();
+ }
+ let g = 128usize;
+ let uv = |i: usize, j: usize| [lo[0] + (hi[0] - lo[0]) * i as f64 / g as f64, lo[1] + (hi[1] - lo[1]) * j as f64 / g as f64];
+ let f = |p: [f64; 2]| s.normal(p).map_or(f64::NAN, |n| n.dot(d));
+ let vals: Vec<f64> = (0..=g).flat_map(|j| (0..=g).map(move |i| (i, j))).map(|(i, j)| f(uv(i, j))).collect();
+ let val = |i: usize, j: usize| vals.get(j * (g + 1) + i).copied().unwrap_or(f64::NAN);
+ let zero = |a: [f64; 2], b: [f64; 2], fa: f64| -> [f64; 2] {
+ let (mut lo, mut hi, mut flo) = (a, b, fa);
+ for _ in 0..50 {
+ let m = [0.5 * (lo[0] + hi[0]), 0.5 * (lo[1] + hi[1])];
+ let fm = f(m);
+ if fm.is_nan() {
+ break;
+ }
+ if (fm > 0.) == (flo > 0.) {
+ lo = m;
+ flo = fm;
+ } else {
+ hi = m;
+ }
+ }
+ [0.5 * (lo[0] + hi[0]), 0.5 * (lo[1] + hi[1])]
+ };
+ // Edge ids: horizontal (i,j)-(i+1,j) = 2k, vertical (i,j)-(i,j+1) = 2k+1, k = j*(g+1)+i.
+ let mut points = std::collections::BTreeMap::new();
+ let mut crossing = |id: usize, a: (usize, usize), b: (usize, usize)| -> Option<usize> {
+ let (fa, fb) = (val(a.0, a.1), val(b.0, b.1));
+ if fa.is_nan() || fb.is_nan() || (fa > 0.) == (fb > 0.) {
+ return None;
+ }
+ points.entry(id).or_insert_with(|| zero(uv(a.0, a.1), uv(b.0, b.1), fa));
+ Some(id)
+ };
+ let mut links: std::collections::BTreeMap<usize, Vec<usize>> = std::collections::BTreeMap::new();
+ for j in 0..g {
+ for i in 0..g {
+ let k = |i: usize, j: usize| j * (g + 1) + i;
+ let e = [
+ crossing(2 * k(i, j), (i, j), (i + 1, j)),
+ crossing(2 * k(i + 1, j) + 1, (i + 1, j), (i + 1, j + 1)),
+ crossing(2 * k(i, j + 1), (i, j + 1), (i + 1, j + 1)),
+ crossing(2 * k(i, j) + 1, (i, j), (i, j + 1)),
+ ];
+ let found: Vec<usize> = e.iter().flatten().copied().collect();
+ let pairs: Vec<(usize, usize)> = match found.as_slice() {
+ [a, b] => vec![(*a, *b)],
+ [a, b, c, dd] => {
+ let centre = f([0.5 * (uv(i, j)[0] + uv(i + 1, j)[0]), 0.5 * (uv(i, j)[1] + uv(i, j + 1)[1])]);
+ if (centre > 0.) == (val(i, j) > 0.) { vec![(*a, *b), (*c, *dd)] } else { vec![(*a, *dd), (*b, *c)] }
+ }
+ _ => Vec::new(),
+ };
+ for (a, b) in pairs {
+ links.entry(a).or_default().push(b);
+ links.entry(b).or_default().push(a);
+ }
+ }
+ }
+ // Chain the links into polylines.
+ let mut used = std::collections::BTreeSet::new();
+ let mut chains = Vec::new();
+ let starts: Vec<usize> = links.iter().filter(|(_, v)| v.len() == 1).map(|(k, _)| *k).chain(links.keys().copied()).collect();
+ for s0 in starts {
+ if used.contains(&s0) {
+ continue;
+ }
+ let mut chain = vec![s0];
+ used.insert(s0);
+ let mut cur = s0;
+ while let Some(next) = links.get(&cur).and_then(|v| v.iter().find(|n| !used.contains(*n)).copied()) {
+ used.insert(next);
+ chain.push(next);
+ cur = next;
+ }
+ // Close loops back to their start.
+ if chain.len() > 2 && links.get(&cur).is_some_and(|v| v.contains(&s0)) {
+ chain.push(s0);
+ }
+ if chain.len() >= 2 {
+ chains.push(chain);
+ }
+ }
+ let mut out = Vec::new();
+ for chain in chains {
+ let uvs: Vec<[f64; 2]> = chain.iter().filter_map(|id| points.get(id).copied()).collect();
+ let pts: Vec<Vec3> = uvs.iter().map(|p| s.point(*p)).collect();
+ // Deviation: refine each chord's midpoint onto the curve across the chord.
+ let mut dev = 0f64;
+ for (w, q) in uvs.windows(2).zip(pts.windows(2)) {
+ let (Some(a), Some(b), Some(pa), Some(pb)) = (w.first(), w.get(1), q.first(), q.get(1)) else { continue };
+ let m = [0.5 * (a[0] + b[0]), 0.5 * (a[1] + b[1])];
+ let n = [-(b[1] - a[1]), b[0] - a[0]];
+ let (x, y) = ([m[0] - n[0], m[1] - n[1]], [m[0] + n[0], m[1] + n[1]]);
+ let (fx, fy) = (f(x), f(y));
+ if fx.is_nan() || fy.is_nan() || (fx > 0.) == (fy > 0.) {
+ continue;
+ }
+ let exact = s.point(zero(x, y, fx));
+ dev = dev.max(exact.dist_to_segment(*pa, *pb));
+ }
+ out.push((C3::Polyline(pts), dev));
+ }
+ out
+}
diff --git a/crates/geom/src/hlr/surface.rs b/crates/geom/src/hlr/surface.rs
new file mode 100644
index 0000000000..d8c3dfc766
--- /dev/null
+++ b/crates/geom/src/hlr/surface.rs
@@ -0,0 +1,1298 @@
+//! Surfaces of portable B-rep faces with a parameter chart, inversion, ray intersection and
+//! analytic recognition. Planes are closed form; revolutions are reduced to their 2D profile;
+//! spline surfaces use Newton iterations seeded from a sample grid.
+
+use super::HlrError;
+use super::curve::{C3, as_circle, frame_axes, v3};
+use crate::Vec3;
+use crate::brep::{Frame, Surface};
+use crate::bspline::{HPoint, NurbsSurface};
+
+const TAU: f64 = std::f64::consts::TAU;
+
+#[derive(Clone, Debug)]
+pub(crate) struct Rev {
+ o: Vec3,
+ pub a: Vec3,
+ e1: Vec3,
+ e2: Vec3,
+ profile: C3,
+ dom: [f64; 2],
+ theta: [f64; 2],
+ closed: bool,
+ /// Profile samples `[s, r, h]`.
+ samples: Vec<[f64; 3]>,
+ pub rmax: f64,
+ hrange: [f64; 2],
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct Nurbs {
+ s: NurbsSurface,
+ dom: [[f64; 2]; 2],
+ g: usize,
+ /// `(g+1)²` samples, u fastest.
+ grid: Vec<Vec3>,
+}
+
+#[derive(Clone, Debug)]
+pub(crate) enum S3 {
+ Plane { o: Vec3, u: Vec3, v: Vec3, n: Vec3 },
+ Rev(Box<Rev>),
+ Nurbs(Box<Nurbs>),
+}
+
+/// What a surface is, when it is a quadric or torus regardless of its record.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(crate) enum Analytic {
+ Plane,
+ /// A point on the axis, unit axis, radius.
+ Cylinder {
+ p: Vec3,
+ a: Vec3,
+ r: f64,
+ },
+ /// Apex, unit axis (opening direction), half angle.
+ Cone {
+ apex: Vec3,
+ a: Vec3,
+ half: f64,
+ },
+ Sphere {
+ c: Vec3,
+ r: f64,
+ },
+ Torus {
+ c: Vec3,
+ a: Vec3,
+ major: f64,
+ minor: f64,
+ },
+ Other,
+}
+
+impl Analytic {
+ /// Distance from `q` to the whole surface (a cone's nappe near `q`); infinite for planes
+ /// and other surfaces, which are not checked this way.
+ fn distance(&self, q: Vec3) -> f64 {
+ let rh = |o: Vec3, a: Vec3| {
+ let w = q - o;
+ let h = w.dot(a);
+ ((w - a * h).len(), h)
+ };
+ match *self {
+ Analytic::Cylinder { p, a, r } => (rh(p, a).0 - r).abs(),
+ Analytic::Cone { apex, a, half } => {
+ let (rho, h) = rh(apex, a);
+ (rho * half.cos() - h * half.sin()).abs()
+ }
+ Analytic::Sphere { c, r } => (q.dist(c) - r).abs(),
+ Analytic::Torus { c, a, major, minor } => {
+ let (rho, h) = rh(c, a);
+ ((rho - major).hypot(h) - minor).abs()
+ }
+ Analytic::Plane | Analytic::Other => f64::INFINITY,
+ }
+ }
+
+ /// The degree of the surface's implicit equation: 2 for quadrics, 4 for a torus.
+ fn implicit_degree(&self) -> usize {
+ match self {
+ Analytic::Torus { .. } => 4,
+ _ => 2,
+ }
+ }
+}
+
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct Hit {
+ pub lam: f64,
+ pub uv: [f64; 2],
+ pub grazing: bool,
+}
+
+fn perp(a: Vec3) -> Vec3 {
+ a.any_perp().normalized().unwrap_or(Vec3::new(1., 0., 0.))
+}
+
+impl S3 {
+ pub fn new(s: &Surface) -> Result<S3, HlrError> {
+ Ok(match s {
+ Surface::Plane { origin, u_axis, v_axis } => {
+ let (u, v) = (v3(*u_axis), v3(*v_axis));
+ let n = u.cross(v).normalized().ok_or(HlrError::Unsupported("degenerate plane"))?;
+ S3::Plane { o: v3(*origin), u, v, n }
+ }
+ // The plane through three points: parameter (1, 0) at `u_point`, (0, 1) at `v_point`.
+ Surface::PlaneThrough { origin, u_point, v_point } => {
+ let o = v3(*origin);
+ let (u, v) = (v3(*u_point) - o, v3(*v_point) - o);
+ let n = u.cross(v).normalized().ok_or(HlrError::Unsupported("degenerate plane"))?;
+ S3::Plane { o, u, v, n }
+ }
+ // A revolution mapped by an affine placement, which may scale it unevenly.
+ Surface::PlacedRevolution { .. } => return Err(HlrError::Unsupported("placed revolution surface")),
+ Surface::Spline { u_knots, v_knots, points } => {
+ let h = points.iter().map(|r| r.iter().map(|p| [p[0], p[1], p[2], 1.]).collect()).collect::<Vec<Vec<_>>>();
+ S3::Nurbs(Box::new(Nurbs::new(u_knots, v_knots, &h)?))
+ }
+ Surface::RationalSpline { u_knots, v_knots, homogeneous } => S3::Nurbs(Box::new(Nurbs::new(u_knots, v_knots, homogeneous)?)),
+ Surface::Revolution { profile, origin, axis, angle } => {
+ let (c, _) = C3::new(profile)?;
+ S3::Rev(Box::new(Rev::new(v3(*origin), v3(*axis), None, c, *angle)?))
+ }
+ Surface::Cylinder { frame, radius, angle, height } => {
+ let (o, x, _, z) = axes(frame);
+ let line = C3::Line { a: o + x * *radius + z * height[0], b: o + x * *radius + z * height[1] };
+ S3::Rev(Box::new(Rev::new(o, z, Some(x), line, *angle)?))
+ }
+ Surface::Cone { frame, radius_at_origin, half_angle, angle, height } => {
+ let (o, x, _, z) = axes(frame);
+ let r = |h: f64| radius_at_origin + h * half_angle.tan();
+ let line = C3::Line { a: o + x * r(height[0]) + z * height[0], b: o + x * r(height[1]) + z * height[1] };
+ S3::Rev(Box::new(Rev::new(o, z, Some(x), line, *angle)?))
+ }
+ Surface::Sphere { frame, radius, longitude, latitude } => {
+ let (o, x, _, z) = axes(frame);
+ let arc = C3::Arc { o, x, y: z, r: [*radius, *radius], range: *latitude };
+ S3::Rev(Box::new(Rev::new(o, z, Some(x), arc, *longitude)?))
+ }
+ Surface::Torus { frame, major_radius, minor_radius, longitude, meridian } => {
+ let (o, x, _, z) = axes(frame);
+ let arc = C3::Arc { o: o + x * *major_radius, x, y: z, r: [*minor_radius, *minor_radius], range: *meridian };
+ S3::Rev(Box::new(Rev::new(o, z, Some(x), arc, *longitude)?))
+ }
+ })
+ }
+
+ /// The recognised quadric or torus as a revolution chart: closed-form inversion and exact
+ /// points for trimming, whatever record (spline, rational spline) the face was stored as.
+ /// `h` bounds the axial extent of cylinders and cones (the face's boundary along the axis);
+ /// `toward` points from a sphere's centre to the face.
+ pub fn from_analytic(an: &Analytic, h: [f64; 2], toward: Vec3) -> Option<S3> {
+ let rev = match *an {
+ Analytic::Cylinder { p, a, r } => {
+ let e1 = perp(a);
+ Rev::new(p, a, Some(e1), C3::Line { a: p + e1 * r + a * h[0], b: p + e1 * r + a * h[1] }, [0., TAU])
+ }
+ Analytic::Cone { apex, a, half } => {
+ let e1 = perp(a);
+ let at = |x: f64| apex + a * x + e1 * (x * half.tan());
+ Rev::new(apex, a, Some(e1), C3::Line { a: at(h[0].max(0.)), b: at(h[1].max(0.)) }, [0., TAU])
+ }
+ Analytic::Sphere { c, r } => {
+ // An axis square to the patch's direction keeps the poles off the patch.
+ let a = perp(toward);
+ let e1 = toward.normalized().unwrap_or_else(|| perp(a));
+ let half = std::f64::consts::FRAC_PI_2;
+ Rev::new(c, a, Some(e1), C3::Arc { o: c, x: e1, y: a, r: [r, r], range: [-half, half] }, [0., TAU])
+ }
+ Analytic::Torus { c, a, major, minor } => {
+ let e1 = perp(a);
+ Rev::new(c, a, Some(e1), C3::Arc { o: c + e1 * major, x: e1, y: a, r: [minor, minor], range: [0., TAU] }, [0., TAU])
+ }
+ Analytic::Plane | Analytic::Other => return None,
+ };
+ rev.ok().map(|r| S3::Rev(Box::new(r)))
+ }
+
+ /// A box that contains the whole surface for certain: the control-point hull of a spline
+ /// (weights are positive), the turned profile's hull for a revolution; `None` for planes.
+ pub fn bound(&self) -> Option<(Vec3, Vec3)> {
+ let hull = |pts: &mut dyn Iterator<Item = Vec3>| {
+ pts.fold(None, |acc: Option<(Vec3, Vec3)>, p| Some(acc.map_or((p, p), |(lo, hi)| (lo.min(p), hi.max(p)))))
+ };
+ match self {
+ S3::Plane { .. } => None,
+ S3::Nurbs(n) => hull(&mut n.s.homogeneous().iter().filter_map(|h| h.project())),
+ S3::Rev(r) => {
+ // Radial distance is convex, so its maximum over the profile's hull is at a vertex.
+ let pts: Vec<Vec3> = match &r.profile {
+ C3::Line { a, b } => vec![*a, *b],
+ C3::Polyline(p) => p.clone(),
+ C3::Spline { points, .. } => {
+ points.iter().filter(|h| h[3] > 0.).map(|h| Vec3::new(h[0] / h[3], h[1] / h[3], h[2] / h[3])).collect()
+ }
+ C3::Arc { o, x, y, r: rad, .. } => {
+ // The whole circle's bounding square in its plane.
+ let m = rad[0].max(rad[1]);
+ vec![*o + *x * m + *y * m, *o + *x * m - *y * m, *o - *x * m + *y * m, *o - *x * m - *y * m]
+ }
+ };
+ let (mut rmax, mut h0, mut h1) = (0f64, f64::MAX, f64::MIN);
+ for p in &pts {
+ let w = *p - r.o;
+ let h = w.dot(r.a);
+ rmax = rmax.max((w - r.a * h).len());
+ h0 = h0.min(h);
+ h1 = h1.max(h);
+ }
+ if !(h1 >= h0) {
+ return None;
+ }
+ let (c0, c1) = (r.o + r.a * h0, r.o + r.a * h1);
+ let ext = |k: f64| rmax * (1. - k * k).max(0.).sqrt();
+ let e = Vec3::new(ext(r.a.x), ext(r.a.y), ext(r.a.z));
+ Some((c0.min(c1) - e, c0.max(c1) + e))
+ }
+ }
+ }
+
+ /// Silhouette points of a revolution for direction `d`, traced along the profile: at each
+ /// profile parameter the normal is perpendicular to `d` at up to two angles. Returns
+ /// polylines of exact points with their chord deviation, and exact circles when `d` is the axis.
+ pub fn rev_silhouette(&self, d: Vec3) -> Vec<(C3, f64)> {
+ let S3::Rev(r) = self else { return Vec::new() };
+ r.silhouette(d)
+ }
+
+ /// A spline patch whose control points all lie in one plane (to `tol` of its size) as that
+ /// plane; the convex hull property puts the whole patch in it.
+ pub fn flat(&self, tol: f64) -> Option<S3> {
+ let S3::Nurbs(n) = self else { return None };
+ let pts: Vec<Vec3> = n.s.homogeneous().iter().filter_map(|h| h.project()).collect();
+ let o = *pts.first()?;
+ let far = |key: &dyn Fn(Vec3) -> f64| pts.iter().copied().max_by(|a, b| key(*a).total_cmp(&key(*b)));
+ let p1 = far(&|p| p.dist(o))?;
+ let u = (p1 - o).normalized()?;
+ let p2 = far(&|p| (p - o).cross(u).len())?;
+ let nrm = u.cross(p2 - o).normalized()?;
+ let size = (p1 - o).len();
+ pts.iter().all(|p| (*p - o).dot(nrm).abs() <= tol * size).then(|| S3::Plane { o, u, v: nrm.cross(u), n: nrm })
+ }
+
+ pub fn domain(&self) -> [[f64; 2]; 2] {
+ match self {
+ S3::Plane { .. } => [[f64::NEG_INFINITY, f64::INFINITY]; 2],
+ S3::Rev(r) => [r.theta, r.dom],
+ S3::Nurbs(n) => n.dom,
+ }
+ }
+
+ pub fn periods(&self) -> [Option<f64>; 2] {
+ match self {
+ S3::Rev(r) => [((r.theta[1] - r.theta[0]) >= TAU - 1e-9).then_some(TAU), r.closed.then_some(r.dom[1] - r.dom[0])],
+ _ => [None, None],
+ }
+ }
+
+ pub fn point(&self, uv: [f64; 2]) -> Vec3 {
+ match self {
+ S3::Plane { o, u, v, .. } => *o + *u * uv[0] + *v * uv[1],
+ S3::Rev(r) => r.point(uv),
+ S3::Nurbs(n) => n.point(uv),
+ }
+ }
+
+ pub fn partials(&self, uv: [f64; 2]) -> (Vec3, Vec3) {
+ match self {
+ S3::Plane { u, v, .. } => (*u, *v),
+ _ => {
+ let d = self.domain();
+ let fd = |k: usize| {
+ let span = d[k][1] - d[k][0];
+ let h = span * 1e-6;
+ let lo = if self.periods()[k].is_some() { uv[k] - h } else { (uv[k] - h).max(d[k][0]) };
+ let hi = if self.periods()[k].is_some() { uv[k] + h } else { (uv[k] + h).min(d[k][1]) };
+ let (mut a, mut b) = (uv, uv);
+ a[k] = lo;
+ b[k] = hi;
+ if hi - lo <= 0. { Vec3::ZERO } else { (self.point(b) - self.point(a)) / (hi - lo) }
+ };
+ (fd(0), fd(1))
+ }
+ }
+ }
+
+ /// The chart normal `Su x Sv`, unit, or `None` at a singular point.
+ pub fn normal(&self, uv: [f64; 2]) -> Option<Vec3> {
+ match self {
+ S3::Plane { n, .. } => Some(*n),
+ _ => {
+ let (su, sv) = self.partials(uv);
+ su.cross(sv).normalized()
+ }
+ }
+ }
+
+ /// Chart coordinates of a point on (or very near) the surface. `hint` guides spline
+ /// Newton iterations and the choice of periodic branch.
+ pub fn inverse(&self, p: Vec3, hint: Option<[f64; 2]>) -> Option<[f64; 2]> {
+ match self {
+ S3::Plane { o, u, v, .. } => {
+ let w = p - *o;
+ let (uu, uv, vv) = (u.dot(*u), u.dot(*v), v.dot(*v));
+ let det = uu * vv - uv * uv;
+ if det.abs() <= 1e-300 {
+ return None;
+ }
+ let (bu, bv) = (w.dot(*u), w.dot(*v));
+ Some([(bu * vv - bv * uv) / det, (bv * uu - bu * uv) / det])
+ }
+ S3::Rev(r) => r.inverse(p, hint),
+ S3::Nurbs(n) => n.inverse(p, hint),
+ }
+ }
+
+ /// Ray hits along unit `d` from `p0` with `lam` in `range` (the face's box along the ray).
+ pub fn ray(&self, p0: Vec3, d: Vec3, range: [f64; 2], out: &mut Vec<Hit>) {
+ match self {
+ S3::Plane { n, .. } => {
+ let nd = n.dot(d);
+ if nd.abs() < 1e-12 {
+ return;
+ }
+ let lam = n.dot(self.point([0., 0.]) - p0) / nd;
+ if lam >= range[0]
+ && lam <= range[1]
+ && let Some(uv) = self.inverse(p0 + d * lam, None)
+ {
+ out.push(Hit { lam, uv, grazing: nd.abs() < 1e-6 });
+ }
+ }
+ S3::Rev(r) => r.ray(p0, d, range, out),
+ S3::Nurbs(n) => n.ray(p0, d, range, out),
+ }
+ }
+
+ /// Ray hits using the recognised analytic form when there is one (closed form for
+ /// quadrics, a sampled quartic for tori), else the record's own intersection.
+ pub fn ray_as(&self, an: &Analytic, p0: Vec3, d: Vec3, range: [f64; 2], out: &mut Vec<Hit>) {
+ let lams = match *an {
+ Analytic::Cylinder { p, a, r } => {
+ let (w, v) = (p0 - p, d - a * d.dot(a));
+ let w = w - a * w.dot(a);
+ quadratic(v.dot(v), 2. * v.dot(w), w.dot(w) - r * r)
+ }
+ Analytic::Cone { apex, a, half } => {
+ let w = p0 - apex;
+ let c2 = half.cos().powi(2);
+ let (da, wa) = (d.dot(a), w.dot(a));
+ let roots = quadratic(da * da - c2, 2. * (da * wa - c2 * d.dot(w)), wa * wa - c2 * w.dot(w));
+ roots.into_iter().filter(|(l, _)| (w + d * *l).dot(a) >= 0.).collect()
+ }
+ Analytic::Sphere { c, r } => {
+ let w = p0 - c;
+ quadratic(1., 2. * d.dot(w), w.dot(w) - r * r)
+ }
+ Analytic::Torus { c, a, major, minor } => torus_roots(p0 - c, d, a, major, minor, range),
+ Analytic::Plane | Analytic::Other => return self.ray(p0, d, range, out),
+ };
+ for (lam, grazing) in lams {
+ if lam >= range[0] && lam <= range[1] {
+ // The analytic surface extends past this record's domain: keep hits on it only.
+ let p = p0 + d * lam;
+ if let Some(uv) = self.inverse(p, None).filter(|uv| self.point(*uv).dist(p) <= 1e-7 * (1. + p.len())) {
+ out.push(Hit { lam, uv, grazing });
+ }
+ }
+ }
+ }
+
+ /// Which analytic surface this is, checked at sample points to `tol` relative to its size.
+ pub fn analytic(&self, tol: f64) -> Analytic {
+ match self {
+ S3::Plane { .. } => Analytic::Plane,
+ S3::Rev(r) => r.analytic(tol),
+ S3::Nurbs(n) => n.analytic(tol),
+ }
+ }
+}
+
+/// Real roots of `a x^2 + b x + c`, a double root flagged as grazing.
+pub(crate) fn quadratic(a: f64, b: f64, c: f64) -> Vec<(f64, bool)> {
+ let scale = b * b + (a * c).abs();
+ if a.abs() <= 1e-14 * (1. + b.abs()) {
+ return if b.abs() > 1e-300 { vec![(-c / b, false)] } else { Vec::new() };
+ }
+ let disc = b * b - 4. * a * c;
+ if disc < -1e-12 * scale {
+ return Vec::new();
+ }
+ if disc <= 1e-12 * scale {
+ return vec![(-b / (2. * a), true)];
+ }
+ // Numerically stable pair.
+ let q = -0.5 * (b + b.signum() * disc.sqrt());
+ vec![(q / a, false), (c / q, false)]
+}
+
+/// Roots of the torus implicit function along a ray, by sampling and bisection; dips that
+/// touch zero without a sign change are grazing.
+pub(crate) fn torus_roots(w: Vec3, d: Vec3, a: Vec3, big: f64, small: f64, range: [f64; 2]) -> Vec<(f64, bool)> {
+ // Signed distance from the tube: distance to the centre circle less the tube radius,
+ // computed directly (no quartic), so a thin tube on a large ring keeps its precision.
+ let g = |l: f64| {
+ let p = w + d * l;
+ let z = p.dot(a);
+ let rho = (p - a * z).len();
+ (rho - big).hypot(z) - small
+ };
+ // Sample only where the ray is inside the shell |z| <= r, R - r <= rho <= R + r, in steps
+ // of a quarter of the tube radius: the shell is short along any ray, so the steps are few.
+ // The shell is padded: a crossing exactly on its surface (rho = R + r at z = 0, say) must
+ // fall strictly inside a sampled piece.
+ let m = 0.5 * small + 1e-9 * big;
+ let (z0, dz) = (w.dot(a), d.dot(a));
+ let mut span = range;
+ if dz.abs() > 1e-300 {
+ let (l0, l1) = ((-small - m - z0) / dz, (small + m - z0) / dz);
+ span = [span[0].max(l0.min(l1)), span[1].min(l0.max(l1))];
+ } else if z0.abs() > small + m {
+ return Vec::new();
+ }
+ // rho^2 along the ray: |w_perp + l d_perp|^2.
+ let (wp, dp) = (w - a * z0, d - a * dz);
+ let (qa, qb, qc) = (dp.dot(dp), 2. * wp.dot(dp), wp.dot(wp));
+ let within = |r2: f64| -> Option<[f64; 2]> {
+ // Where rho^2 <= r2.
+ if qa <= 1e-300 {
+ return (qc <= r2).then_some([f64::NEG_INFINITY, f64::INFINITY]);
+ }
+ let disc = qb * qb - 4. * qa * (qc - r2);
+ (disc >= 0.).then(|| [(-qb - disc.sqrt()) / (2. * qa), (-qb + disc.sqrt()) / (2. * qa)])
+ };
+ let Some(outer) = within((big + small + m).powi(2)) else { return Vec::new() };
+ span = [span[0].max(outer[0]), span[1].min(outer[1])];
+ if !(span[1] > span[0]) {
+ return Vec::new();
+ }
+ // Remove the inside of the inner radius, leaving up to two pieces.
+ let mut pieces = vec![span];
+ if big > small + m
+ && let Some(inner) = within((big - small - m).powi(2))
+ {
+ pieces = vec![[span[0], span[1].min(inner[0])], [span[0].max(inner[1]), span[1]]];
+ }
+ // |g| is 1-Lipschitz along the ray: two samples whose values share a sign and add up to
+ // more than their distance cannot have a crossing between them. Other pairs are halved down
+ // to a thousandth of the tube radius, so a shallow cut through the tube (a chord shorter than
+ // the sample step) is still found.
+ let fine = 1e-3 * small;
+ let mut out = Vec::new();
+ for [s0, s1] in pieces.into_iter().filter(|p| p[1] > p[0]) {
+ let n = ((s1 - s0) / (0.25 * small)).ceil().clamp(8., 1_000_000.) as usize;
+ let at = |i: usize| s0 + (s1 - s0) * i as f64 / n as f64;
+ let mut stack: Vec<(f64, f64, f64, f64)> = Vec::new();
+ let vals: Vec<f64> = (0..=n).map(|i| g(at(i))).collect();
+ for i in 0..n {
+ if let (Some(&ga), Some(&gb)) = (vals.get(i), vals.get(i + 1)) {
+ stack.push((at(i), at(i + 1), ga, gb));
+ }
+ }
+ stack.reverse();
+ let mut budget = 1_000_000usize;
+ while let Some((lo0, hi0, ga, gb)) = stack.pop() {
+ budget = budget.saturating_sub(1);
+ if budget == 0 {
+ break;
+ }
+ if ga != 0. && gb != 0. && ga.signum() != gb.signum() {
+ let (mut lo, mut hi, mut glo) = (lo0, hi0, ga);
+ for _ in 0..80 {
+ let mid = 0.5 * (lo + hi);
+ let gm = g(mid);
+ if gm.signum() == glo.signum() {
+ lo = mid;
+ glo = gm;
+ } else {
+ hi = mid;
+ }
+ }
+ out.push((0.5 * (lo + hi), false));
+ continue;
+ }
+ if ga.abs() + gb.abs() > hi0 - lo0 {
+ continue;
+ }
+ if hi0 - lo0 <= fine {
+ // Close to the tube without crossing it: a touch when it is a dip inside the shell.
+ let m = 0.5 * (lo0 + hi0);
+ let gm = g(m);
+ if gm > 0. && gm <= ga && gm <= gb && lo0 > s0 && hi0 < s1 && gm < 1e-4 * small.max(1e-9 * big) {
+ out.push((m, true));
+ }
+ continue;
+ }
+ let m = 0.5 * (lo0 + hi0);
+ let gm = g(m);
+ stack.push((m, hi0, gm, gb));
+ stack.push((lo0, m, ga, gm));
+ }
+ }
+ out.sort_by(|x, y| x.0.total_cmp(&y.0));
+ out.dedup_by(|x, y| (x.0 - y.0).abs() <= fine && x.1 == y.1);
+ out
+}
+
+fn axes(f: &Frame) -> (Vec3, Vec3, Vec3, Vec3) {
+ let (o, x, y) = frame_axes(f);
+ (o, x, y, x.cross(y))
+}
+
+impl Rev {
+ fn new(o: Vec3, axis: Vec3, e1: Option<Vec3>, profile: C3, angle: [f64; 2]) -> Result<Rev, HlrError> {
+ let a = axis.normalized().ok_or(HlrError::Unsupported("zero revolution axis"))?;
+ let dom = profile.domain();
+ let e1 = e1.unwrap_or_else(|| {
+ let w = profile.at(dom[0]) - o;
+ (w - a * w.dot(a)).normalized().unwrap_or_else(|| perp(a))
+ });
+ let e2 = a.cross(e1);
+ let closed = profile.at(dom[0]).dist(profile.at(dom[1])) <= 1e-9 * (1. + profile.at(dom[0]).dist(o));
+ let n = 512;
+ let mut samples = Vec::with_capacity(n + 1);
+ let (mut rmax, mut hlo, mut hhi) = (0f64, f64::MAX, f64::MIN);
+ for i in 0..=n {
+ let s = dom[0] + (dom[1] - dom[0]) * i as f64 / n as f64;
+ let w = profile.at(s) - o;
+ let h = w.dot(a);
+ let r = (w - a * h).len();
+ rmax = rmax.max(r);
+ hlo = hlo.min(h);
+ hhi = hhi.max(h);
+ samples.push([s, r, h]);
+ }
+ if !(rmax.is_finite() && hlo.is_finite() && hhi.is_finite()) {
+ return Err(HlrError::Unsupported("non-finite revolution profile"));
+ }
+ // Chart theta is measured from e1; a full turn is [0, 2pi).
+ let theta = if angle[1] - angle[0] >= TAU - 1e-9 { [0., TAU] } else { angle };
+ Ok(Rev { o, a, e1, e2, profile, dom, theta, closed, samples, rmax, hrange: [hlo, hhi] })
+ }
+
+ fn rh(&self, s: f64) -> [f64; 2] {
+ let w = self.profile.at(s) - self.o;
+ let h = w.dot(self.a);
+ [(w - self.a * h).len(), h]
+ }
+
+ fn rh_d(&self, s: f64) -> [f64; 2] {
+ // Exact for line and arc profiles: a one-sided difference at the domain's ends misses
+ // zeros that sit there (a half torus's equators). A difference for the rest.
+ let dw = match &self.profile {
+ C3::Line { a, b } => Some(*b - *a),
+ C3::Arc { x, y, r, .. } => Some(*x * (-r[0] * s.sin()) + *y * (r[1] * s.cos())),
+ _ => None,
+ };
+ if let Some(dw) = dw {
+ let w = self.profile.at(s) - self.o;
+ let radial = w - self.a * w.dot(self.a);
+ let r = radial.len();
+ if r > 1e-12 * (1. + self.rmax) {
+ return [radial.dot(dw) / r, dw.dot(self.a)];
+ }
+ }
+ let h = (self.dom[1] - self.dom[0]) * 1e-7;
+ let (a, b) = ((s - h).max(self.dom[0]), (s + h).min(self.dom[1]));
+ if b - a <= 0. {
+ return [0., 0.];
+ }
+ let (p, q) = (self.rh(a), self.rh(b));
+ [(q[0] - p[0]) / (b - a), (q[1] - p[1]) / (b - a)]
+ }
+
+ fn point(&self, uv: [f64; 2]) -> Vec3 {
+ let [r, h] = self.rh(uv[1]);
+ self.o + self.a * h + (self.e1 * uv[0].cos() + self.e2 * uv[0].sin()) * r
+ }
+
+ /// Profile parameters where component `k` of the profile's (r, h) tangent vanishes: sign
+ /// changes between samples, refined by bisection, exact zeros at samples, and for a closed
+ /// profile the change across the seam where its ends meet.
+ fn roots(&self, ss: &[f64], k: usize) -> Vec<f64> {
+ let f = |s: f64| self.rh_d(s).get(k).copied().unwrap_or(0.);
+ let vals: Vec<f64> = ss.iter().map(|s| f(*s)).collect();
+ let scale = vals.iter().fold(0f64, |m, v| m.max(v.abs())).max(1e-300);
+ let zero = |v: f64| v.abs() <= 1e-12 * scale;
+ let mut out: Vec<f64> = Vec::new();
+ let mut pairs: Vec<(usize, usize)> = (0..ss.len().saturating_sub(1)).map(|i| (i, i + 1)).collect();
+ if self.closed && ss.len() > 2 {
+ // The last sample repeats the first; the pair across the seam is (n-1, 1).
+ pairs.push((ss.len() - 2, 1));
+ }
+ for (i, sv) in vals.iter().enumerate() {
+ if zero(*sv)
+ && !(self.closed && i + 1 == vals.len())
+ && let Some(s0) = ss.get(i)
+ {
+ out.push(*s0);
+ }
+ }
+ for (i, j) in pairs {
+ let (Some(&a), Some(&b), Some(&sa), Some(&sb)) = (vals.get(i), vals.get(j), ss.get(i), ss.get(j)) else { continue };
+ if zero(a) || zero(b) || a.signum() == b.signum() {
+ continue;
+ }
+ // Across the seam, walk sb forward a period so the interval is increasing.
+ let sb = if sb < sa { sb + (self.dom[1] - self.dom[0]) } else { sb };
+ let wrap = |x: f64| if x > self.dom[1] { x - (self.dom[1] - self.dom[0]) } else { x };
+ let (mut lo, mut hi, mut flo) = (sa, sb, a);
+ for _ in 0..60 {
+ let mid = 0.5 * (lo + hi);
+ let fm = f(wrap(mid));
+ if fm.signum() == flo.signum() && !zero(fm) {
+ lo = mid;
+ flo = fm;
+ } else {
+ hi = mid;
+ }
+ }
+ out.push(wrap(0.5 * (lo + hi)));
+ }
+ out.sort_by(f64::total_cmp);
+ let span = self.dom[1] - self.dom[0];
+ out.dedup_by(|x, y| (*x - *y).abs() <= 1e-9 * span);
+ // A closed profile's start and end are one point: one root there, not two.
+ if self.closed
+ && let (Some(&first), Some(&last)) = (out.first(), out.last())
+ && out.len() > 1
+ && (first + span - last).abs() <= 1e-9 * span
+ {
+ out.pop();
+ }
+ out
+ }
+
+ /// cos(theta - phi) = dr (a.d) / (dh rho) along the profile; see `S3::rev_silhouette`.
+ fn silhouette(&self, d: Vec3) -> Vec<(C3, f64)> {
+ let (d1, d2, da) = (d.dot(self.e1), d.dot(self.e2), d.dot(self.a));
+ let rho = (d1 * d1 + d2 * d2).sqrt();
+ let phi = d2.atan2(d1);
+ let n = 720usize;
+ let mut ss: Vec<f64> = (0..=n).map(|i| self.dom[0] + (self.dom[1] - self.dom[0]) * i as f64 / n as f64).collect();
+ let mut out = Vec::new();
+ if rho > 1e-12 {
+ // The silhouette exists where |dr (a.d)| <= |dh| rho; near the axis direction those
+ // intervals shrink around the zeros of dr, which are sampled so none is stepped over.
+ let extra = self.roots(&ss, 0);
+ ss.extend(extra);
+ ss.sort_by(f64::total_cmp);
+ ss.dedup_by(|x, y| (*x - *y).abs() <= 1e-15 * (self.dom[1] - self.dom[0]));
+ }
+ if rho <= 1e-12 {
+ // Along the axis: circles where the profile runs parallel to the axis (dr = 0).
+ for s0 in self.roots(&ss, 0) {
+ let [r, h] = self.rh(s0);
+ if r > 1e-12 {
+ out.push((C3::Arc { o: self.o + self.a * h, x: self.e1, y: self.e2, r: [r, r], range: [0., TAU] }, 0.));
+ }
+ }
+ return out;
+ }
+ if da.abs() <= 1e-12 {
+ // Square to the axis: where the profile runs radially (dh = 0) the normal is the
+ // axis, square to d for every angle, so the whole parallel circle is a silhouette.
+ for s0 in self.roots(&ss, 1) {
+ let [r, h] = self.rh(s0);
+ if r > 1e-12 {
+ out.push((C3::Arc { o: self.o + self.a * h, x: self.e1, y: self.e2, r: [r, r], range: [0., TAU] }, 0.));
+ }
+ }
+ }
+ let c = |s: f64| {
+ let t = self.rh_d(s);
+ if t[1].abs() <= 1e-300 { f64::INFINITY } else { t[0] * da / (t[1] * rho) }
+ };
+ let at = |sign: f64, s: f64| self.point([phi + sign * c(s).clamp(-1., 1.).acos(), s]);
+ // The parameter between a (|c| <= 1) and b (|c| > 1) where |c| = 1.
+ let edge = |a: f64, b: f64| {
+ let (mut lo, mut hi) = (a, b);
+ for _ in 0..60 {
+ let mid = 0.5 * (lo + hi);
+ if c(mid).abs() <= 1. {
+ lo = mid;
+ } else {
+ hi = mid;
+ }
+ }
+ lo
+ };
+ // Chords are halved where their middle is further than this from the curve; the angle
+ // moves fastest where a branch starts or ends, so uniform samples alone are coarse there.
+ let target = 1e-7 * (1. + self.rmax + (self.hrange[1] - self.hrange[0]));
+ // One polyline per branch while |c| <= 1.
+ for sign in [1., -1.] {
+ let mut run: Vec<f64> = Vec::new();
+ let flush = |run: &mut Vec<f64>, out: &mut Vec<(C3, f64)>| {
+ if run.len() >= 2 {
+ for _ in 0..40 {
+ let mut next = Vec::with_capacity(run.len() * 2);
+ let mut split = false;
+ for w in run.windows(2) {
+ let (Some(&a), Some(&b)) = (w.first(), w.get(1)) else { continue };
+ next.push(a);
+ let m = 0.5 * (a + b);
+ if next.len() < 1 << 16 && at(sign, m).dist_to_segment(at(sign, a), at(sign, b)) > target {
+ next.push(m);
+ split = true;
+ }
+ }
+ if let Some(&last) = run.last() {
+ next.push(last);
+ }
+ *run = next;
+ if !split {
+ break;
+ }
+ }
+ let pts: Vec<Vec3> = run.iter().map(|s| at(sign, *s)).collect();
+ let mut dev = 0f64;
+ for (w, q) in run.windows(2).zip(pts.windows(2)) {
+ let (Some(a), Some(b), Some(pa), Some(pb)) = (w.first(), w.get(1), q.first(), q.get(1)) else { continue };
+ dev = dev.max(at(sign, 0.5 * (a + b)).dist_to_segment(*pa, *pb));
+ }
+ out.push((C3::Polyline(pts), dev));
+ }
+ run.clear();
+ };
+ for i in 0..ss.len() {
+ let Some(&s) = ss.get(i) else { continue };
+ let inside = c(s).abs() <= 1.;
+ let prev = i.checked_sub(1).and_then(|j| ss.get(j).copied());
+ match (inside, prev.map(|p| c(p).abs() <= 1.)) {
+ (true, Some(false)) => {
+ if let Some(p) = prev {
+ run.push(edge(s, p));
+ }
+ run.push(s);
+ }
+ (true, _) => run.push(s),
+ (false, Some(true)) => {
+ if let Some(p) = prev {
+ run.push(edge(p, s));
+ }
+ flush(&mut run, &mut out);
+ }
+ (false, _) => {}
+ }
+ }
+ flush(&mut run, &mut out);
+ }
+ out
+ }
+
+ /// Closest profile parameter to `(r, h)`, with the squared distance.
+ fn closest(&self, q: [f64; 2]) -> (f64, f64) {
+ if let C3::Line { .. } = self.profile {
+ let (p0, p1) = (self.rh(self.dom[0]), self.rh(self.dom[1]));
+ let e = [p1[0] - p0[0], p1[1] - p0[1]];
+ let l2 = e[0] * e[0] + e[1] * e[1];
+ let t = if l2 > 0. { (((q[0] - p0[0]) * e[0] + (q[1] - p0[1]) * e[1]) / l2).clamp(0., 1.) } else { 0. };
+ let s = self.dom[0] + (self.dom[1] - self.dom[0]) * t;
+ let p = self.rh(s);
+ return (s, (p[0] - q[0]).powi(2) + (p[1] - q[1]).powi(2));
+ }
+ // Coarse scan, then the finer samples around the best coarse one.
+ let mut best = (0usize, f64::MAX);
+ for (i, smp) in self.samples.iter().enumerate().step_by(8) {
+ let d2 = (smp[1] - q[0]).powi(2) + (smp[2] - q[1]).powi(2);
+ if d2 < best.1 {
+ best = (i, d2);
+ }
+ }
+ let mut best = (self.samples.get(best.0).map_or(self.dom[0], |s| s[0]), best.1, best.0);
+ for i in best.2.saturating_sub(8)..(best.2 + 9).min(self.samples.len()) {
+ if let Some(smp) = self.samples.get(i) {
+ let d2 = (smp[1] - q[0]).powi(2) + (smp[2] - q[1]).powi(2);
+ if d2 < best.1 {
+ best = (smp[0], d2, i);
+ }
+ }
+ }
+ let best = (best.0, best.1);
+ let mut s = best.0;
+ for _ in 0..30 {
+ let p = self.rh(s);
+ let d = self.rh_d(s);
+ let f = (p[0] - q[0]) * d[0] + (p[1] - q[1]) * d[1];
+ let fp = d[0] * d[0] + d[1] * d[1];
+ if fp <= 1e-300 {
+ break;
+ }
+ let next = (s - f / fp).clamp(self.dom[0], self.dom[1]);
+ if (next - s).abs() <= 1e-15 * (1. + s.abs()) {
+ s = next;
+ break;
+ }
+ s = next;
+ }
+ let p = self.rh(s);
+ (s, (p[0] - q[0]).powi(2) + (p[1] - q[1]).powi(2))
+ }
+
+ fn inverse(&self, p: Vec3, hint: Option<[f64; 2]>) -> Option<[f64; 2]> {
+ let w = p - self.o;
+ let h = w.dot(self.a);
+ let radial = w - self.a * h;
+ let r = radial.len();
+ let theta = if r > 1e-12 * (1. + self.rmax) { radial.dot(self.e2).atan2(radial.dot(self.e1)) } else { hint.map_or(0., |u| u[0]) };
+ let (s, _) = self.closest([r, h]);
+ let mut t = theta;
+ if self.theta[1] - self.theta[0] >= TAU - 1e-9 {
+ t = t.rem_euclid(TAU);
+ } else if t < self.theta[0] {
+ t += TAU;
+ }
+ Some([t, s])
+ }
+
+ /// Signed distance of `(r, h)` from the profile, or `None` beyond an open profile's ends.
+ fn signed(&self, q: [f64; 2]) -> Option<f64> {
+ let (s, d2) = self.closest(q);
+ let at_end = !self.closed && ((s - self.dom[0]).abs() <= 1e-12 * (1. + s.abs()) || (s - self.dom[1]).abs() <= 1e-12 * (1. + s.abs()));
+ let p = self.rh(s);
+ let t = self.rh_d(s);
+ if at_end {
+ // Beyond the end the normal distance is undefined unless q projects onto it.
+ let along = (q[0] - p[0]) * t[0] + (q[1] - p[1]) * t[1];
+ let outward = if (s - self.dom[0]).abs() < (s - self.dom[1]).abs() { -along } else { along };
+ if outward > 1e-12 * (1. + self.rmax) {
+ return None;
+ }
+ }
+ let cross = t[0] * (q[1] - p[1]) - t[1] * (q[0] - p[0]);
+ Some(cross.signum() * d2.sqrt())
+ }
+
+ fn ray(&self, p0: Vec3, d: Vec3, range: [f64; 2], out: &mut Vec<Hit>) {
+ let rh = |lam: f64| {
+ let w = p0 + d * lam - self.o;
+ let h = w.dot(self.a);
+ [(w - self.a * h).len(), h]
+ };
+ // Clip the ray to the bounding cylinder, coarsely, by sampling.
+ let pad = 1e-6 * (1. + self.rmax + (self.hrange[1] - self.hrange[0]));
+ let n = 400usize;
+ let f = |lam: f64| {
+ let q = rh(lam);
+ if q[0] > self.rmax + pad || q[1] < self.hrange[0] - pad || q[1] > self.hrange[1] + pad { None } else { self.signed(q) }
+ };
+ // Values within the noise floor carry no sign (a ray tangent at its start, say).
+ let floor = 1e-9 * (1. + self.rmax + (self.hrange[1] - self.hrange[0]));
+ let mut prev: Option<(f64, f64)> = None;
+ let mut minima: Vec<(f64, f64)> = Vec::new();
+ let mut last: Option<f64> = None;
+ let mut falling = false;
+ let at = |i: usize| range[0] + (range[1] - range[0]) * i as f64 / n as f64;
+ for i in 0..=n {
+ let lam = at(i);
+ let v = f(lam);
+ match (prev, v) {
+ (Some((la, fa)), Some(fb)) if fa.abs() > floor && fb.abs() > floor && fa.signum() != fb.signum() => {
+ let (mut lo, mut hi, mut flo) = (la, lam, fa);
+ for _ in 0..80 {
+ let mid = 0.5 * (lo + hi);
+ match f(mid) {
+ Some(fm) if fm.signum() == flo.signum() => {
+ lo = mid;
+ flo = fm;
+ }
+ Some(_) => hi = mid,
+ None => break,
+ }
+ }
+ let lam = 0.5 * (lo + hi);
+ if lam >= range[0]
+ && let Some(uv) = self.inverse(p0 + d * lam, None)
+ {
+ out.push(Hit { lam, uv, grazing: false });
+ }
+ }
+ _ => {}
+ }
+ // Interior dips only: the range's first sample is never a minimum.
+ if let Some(fb) = v {
+ let a = fb.abs();
+ if let Some(l) = last {
+ if falling && a > l {
+ minima.push((at(i - 1), l));
+ }
+ falling = a < l;
+ }
+ last = Some(a);
+ } else {
+ falling = false;
+ last = None;
+ }
+ match v {
+ Some(fb) if fb.abs() > floor => prev = Some((lam, fb)),
+ Some(_) => {}
+ None => prev = None,
+ }
+ }
+ // Near-tangent rays: a dip close to zero without a sign change.
+ let tol = 1e-4 * (1. + self.rmax);
+ for (lam, a) in minima {
+ if a < tol
+ && lam >= range[0]
+ && !out.iter().any(|h| (h.lam - lam).abs() < 2. * (range[1] - range[0]) / n as f64)
+ && let Some(uv) = self.inverse(p0 + d * lam, None)
+ {
+ out.push(Hit { lam, uv, grazing: true });
+ }
+ }
+ }
+
+ fn analytic(&self, tol: f64) -> Analytic {
+ let size = self.rmax.max(self.hrange[1] - self.hrange[0]).max(1e-9);
+ let pts: Vec<[f64; 2]> = self.samples.iter().map(|s| [s[1], s[2]]).collect();
+ let (Some(first), Some(last)) = (pts.first(), pts.last()) else { return Analytic::Other };
+ // A straight profile: cylinder (constant r), cone, or a plane square to the axis.
+ let e = [last[0] - first[0], last[1] - first[1]];
+ let el = (e[0] * e[0] + e[1] * e[1]).sqrt();
+ let straight = el > 0. && pts.iter().all(|p| ((p[0] - first[0]) * e[1] - (p[1] - first[1]) * e[0]).abs() / el <= tol * size);
+ if straight {
+ if e[0].abs() <= tol * el {
+ return Analytic::Cylinder { p: self.o, a: self.a, r: first[0] };
+ }
+ if e[1].abs() <= tol * el {
+ return Analytic::Plane;
+ }
+ // Apex where r = 0 on the line.
+ let t = -first[0] / e[0];
+ let h_apex = first[1] + t * e[1];
+ let dir = if e[1] * e[0] > 0. { self.a } else { -self.a };
+ let half = (e[0].abs() / el).asin();
+ return Analytic::Cone { apex: self.o + self.a * h_apex, a: dir, half };
+ }
+ // A circular profile: sphere when its centre is on the axis, torus otherwise.
+ if let Some((c, _, r)) = as_circle(&self.profile, tol) {
+ let w = c - self.o;
+ let h = w.dot(self.a);
+ let rc = (w - self.a * h).len();
+ if rc <= tol * size {
+ return Analytic::Sphere { c: self.o + self.a * h, r };
+ }
+ return Analytic::Torus { c: self.o + self.a * h, a: self.a, major: rc, minor: r };
+ }
+ Analytic::Other
+ }
+}
+
+impl Nurbs {
+ fn new(u: &[f64], v: &[f64], rows: &[Vec<[f64; 4]>]) -> Result<Nurbs, HlrError> {
+ let nu = rows.len();
+ let nv = rows.first().map_or(0, Vec::len);
+ let pu = u.len().checked_sub(nu + 1).ok_or(HlrError::Unsupported("surface knots"))?;
+ let pv = v.len().checked_sub(nv + 1).ok_or(HlrError::Unsupported("surface knots"))?;
+ let mut ctrl = Vec::with_capacity(nu * nv);
+ for j in 0..nv {
+ for row in rows {
+ let p = row.get(j).ok_or(HlrError::Unsupported("ragged surface"))?;
+ ctrl.push(HPoint { x: p[0], y: p[1], z: p[2], w: p[3] });
+ }
+ }
+ let s = NurbsSurface::from_homogeneous([pu, pv], [u.to_vec(), v.to_vec()], ctrl).map_err(|_| HlrError::Unsupported("spline surface"))?;
+ let dom = s.domain();
+ let g = (4 * nu.max(nv)).clamp(16, 64);
+ let mut n = Nurbs { s, dom, g, grid: Vec::new() };
+ let mut grid = Vec::with_capacity((g + 1) * (g + 1));
+ for j in 0..=g {
+ for i in 0..=g {
+ grid.push(n.point(n.grid_uv(i, j)));
+ }
+ }
+ if grid.iter().any(|p| !p.is_finite()) {
+ return Err(HlrError::Unsupported("spline surface evaluation"));
+ }
+ n.grid = grid;
+ Ok(n)
+ }
+
+ pub fn grid_uv(&self, i: usize, j: usize) -> [f64; 2] {
+ let f = |k: usize, x: usize| self.dom[k][0] + (self.dom[k][1] - self.dom[k][0]) * x as f64 / self.g as f64;
+ [f(0, i), f(1, j)]
+ }
+
+ fn point(&self, uv: [f64; 2]) -> Vec3 {
+ let u = uv[0].clamp(self.dom[0][0], self.dom[0][1]);
+ let v = uv[1].clamp(self.dom[1][0], self.dom[1][1]);
+ self.s.eval(u, v).unwrap_or(Vec3::new(f64::NAN, f64::NAN, f64::NAN))
+ }
+
+ fn partials(&self, uv: [f64; 2]) -> (Vec3, Vec3) {
+ let fd = |k: usize| {
+ let h = (self.dom[k][1] - self.dom[k][0]) * 1e-6;
+ let (mut a, mut b) = (uv, uv);
+ a[k] = (uv[k] - h).max(self.dom[k][0]);
+ b[k] = (uv[k] + h).min(self.dom[k][1]);
+ if b[k] - a[k] <= 0. { Vec3::ZERO } else { (self.point(b) - self.point(a)) / (b[k] - a[k]) }
+ };
+ (fd(0), fd(1))
+ }
+
+ fn clamp(&self, uv: [f64; 2]) -> [f64; 2] {
+ [uv[0].clamp(self.dom[0][0], self.dom[0][1]), uv[1].clamp(self.dom[1][0], self.dom[1][1])]
+ }
+
+ fn inverse(&self, p: Vec3, hint: Option<[f64; 2]>) -> Option<[f64; 2]> {
+ let mut uv = match hint {
+ Some(h) => self.clamp(h),
+ None => {
+ let mut best = (0usize, f64::MAX);
+ for (k, q) in self.grid.iter().enumerate() {
+ let d = q.dist(p);
+ if d < best.1 {
+ best = (k, d);
+ }
+ }
+ self.grid_uv(best.0 % (self.g + 1), best.0 / (self.g + 1))
+ }
+ };
+ for _ in 0..40 {
+ let (su, sv) = self.partials(uv);
+ let r = self.point(uv) - p;
+ let (a, b, c) = (su.dot(su), su.dot(sv), sv.dot(sv));
+ let det = a * c - b * b;
+ if det.abs() <= 1e-300 {
+ break;
+ }
+ let (gu, gv) = (su.dot(r), sv.dot(r));
+ let du = (gu * c - gv * b) / det;
+ let dv = (gv * a - gu * b) / det;
+ let next = self.clamp([uv[0] - du, uv[1] - dv]);
+ let moved = (next[0] - uv[0]).abs() + (next[1] - uv[1]).abs();
+ uv = next;
+ if moved <= 1e-15 * (1. + uv[0].abs() + uv[1].abs()) {
+ break;
+ }
+ }
+ uv[0].is_finite().then_some(uv)
+ }
+
+ fn ray(&self, p0: Vec3, d: Vec3, range: [f64; 2], out: &mut Vec<Hit>) {
+ let ep = perp(d);
+ let eq = d.cross(ep);
+ let q2 = |p: Vec3| [(p - p0).dot(ep), (p - p0).dot(eq)];
+ let g = self.g;
+ let start = out.len();
+ let proj: Vec<[f64; 2]> = self.grid.iter().map(|p| q2(*p)).collect();
+ for j in 0..g {
+ for i in 0..g {
+ let corners = [(i, j), (i + 1, j), (i + 1, j + 1), (i, j + 1)];
+ let pts: Vec<[f64; 2]> = corners.iter().filter_map(|(a, b)| proj.get(b * (g + 1) + a).copied()).collect();
+ let (mut lo, mut hi) = ([f64::MAX; 2], [f64::MIN; 2]);
+ for p in &pts {
+ lo = [lo[0].min(p[0]), lo[1].min(p[1])];
+ hi = [hi[0].max(p[0]), hi[1].max(p[1])];
+ }
+ let pad = 0.25 * ((hi[0] - lo[0]).max(hi[1] - lo[1]));
+ if lo[0] - pad > 0. || hi[0] + pad < 0. || lo[1] - pad > 0. || hi[1] + pad < 0. {
+ continue;
+ }
+ let (a, b) = (self.grid_uv(i, j), self.grid_uv(i + 1, j + 1));
+ let mut uv = [0.5 * (a[0] + b[0]), 0.5 * (a[1] + b[1])];
+ let mut ok = false;
+ for _ in 0..40 {
+ let p = self.point(uv);
+ let f = q2(p);
+ let (su, sv) = self.partials(uv);
+ let (j11, j12, j21, j22) = (su.dot(ep), sv.dot(ep), su.dot(eq), sv.dot(eq));
+ let det = j11 * j22 - j12 * j21;
+ if det.abs() <= 1e-300 {
+ break;
+ }
+ let du = (f[0] * j22 - f[1] * j12) / det;
+ let dv = (f[1] * j11 - f[0] * j21) / det;
+ uv = self.clamp([uv[0] - du, uv[1] - dv]);
+ if du.abs() + dv.abs() <= 1e-14 * (1. + uv[0].abs() + uv[1].abs()) {
+ let r = q2(self.point(uv));
+ ok = r[0].abs() + r[1].abs() <= 1e-9 * (1. + self.size_hint());
+ break;
+ }
+ }
+ // Keep roots inside this cell (with slack) so neighbouring cells don't repeat them.
+ let slack = [(b[0] - a[0]) * 1e-6, (b[1] - a[1]) * 1e-6];
+ if !ok || uv[0] < a[0] - slack[0] || uv[0] > b[0] + slack[0] || uv[1] < a[1] - slack[1] || uv[1] > b[1] + slack[1] {
+ continue;
+ }
+ let p = self.point(uv);
+ let lam = (p - p0).dot(d);
+ if lam >= range[0] && lam <= range[1] && !out.iter().skip(start).any(|h| (h.lam - lam).abs() <= 1e-9 * (1. + lam)) {
+ let (su, sv) = self.partials(uv);
+ let grazing = su.cross(sv).normalized().is_none_or(|n| n.dot(d).abs() < 1e-6);
+ out.push(Hit { lam, uv, grazing });
+ }
+ }
+ }
+ }
+
+ fn size_hint(&self) -> f64 {
+ self.grid.first().zip(self.grid.last()).map_or(1., |(a, b)| a.dist(*b))
+ }
+
+ /// The recognised form, checked over the whole patch: on each knot span the implicit
+ /// equation of a surface of degree d, multiplied out by the weight, is a polynomial of
+ /// degree d p by d q in the span's parameters, so it is zero everywhere when zero at
+ /// d p + 1 by d q + 1 points. It is checked at d p + 3 by d q + 3 Chebyshev points of
+ /// every span and the span's corners: nothing between samples can hide a bump.
+ fn analytic(&self, tol: f64) -> Analytic {
+ let an = self.candidate(tol);
+ if matches!(an, Analytic::Other | Analytic::Plane) {
+ return an;
+ }
+ let pts: Vec<Vec3> = self.s.homogeneous().iter().filter_map(|h| h.project()).collect();
+ let hull = pts.iter().skip(1).fold(pts.first().map(|p| (*p, *p)), |acc, p| acc.map(|(lo, hi)| (lo.min(*p), hi.max(*p))));
+ let size = hull.map_or(1., |(lo, hi)| (hi - lo).len()).max(1e-9);
+ let [pu, pv] = self.s.degree();
+ let d = an.implicit_degree();
+ let spans = |k: usize| -> Vec<[f64; 2]> {
+ let (Some(ks), Some(dom)) = (self.s.knots().get(k), self.dom.get(k)) else { return Vec::new() };
+ let mut cuts: Vec<f64> = ks.iter().copied().filter(|x| *x > dom[0] && *x < dom[1]).collect();
+ cuts.push(dom[0]);
+ cuts.push(dom[1]);
+ cuts.sort_by(f64::total_cmp);
+ cuts.dedup();
+ cuts.windows(2).filter_map(|w| Some([*w.first()?, *w.get(1)?])).collect()
+ };
+ let nodes = |deg: usize, s: [f64; 2]| -> Vec<f64> {
+ let n = d * deg + 3;
+ let (mid, half) = (0.5 * (s[0] + s[1]), 0.5 * (s[1] - s[0]));
+ let inner = (0..n).map(move |k| mid + half * (std::f64::consts::PI * (2 * k + 1) as f64 / (2 * n) as f64).cos());
+ [s[0], s[1]].into_iter().chain(inner).collect()
+ };
+ // As for circles (curve::as_circle): the largest distance at the points, times the
+ // tensor Lebesgue constant (below 16) and the weights' spread to the power d, bounds the
+ // distance anywhere on the patch.
+ let (w_min, w_max) = self.s.homogeneous().iter().fold((f64::MAX, f64::MIN), |(lo, hi), h| (lo.min(h.w), hi.max(h.w)));
+ if !(w_min > 0. && w_max.is_finite()) {
+ return Analytic::Other;
+ }
+ let (su, sv) = (spans(0), spans(1));
+ let mut far = 0f64;
+ for a in &su {
+ let us = nodes(pu, *a);
+ for b in &sv {
+ for v in nodes(pv, *b) {
+ for u in &us {
+ far = far.max(an.distance(self.point([*u, v])));
+ }
+ }
+ }
+ }
+ if 16. * (w_max / w_min).powi(d as i32) * far <= tol * size { an } else { Analytic::Other }
+ }
+
+ /// Cylinder/cone/sphere/torus candidates from iso-curves and grid samples.
+ fn candidate(&self, tol: f64) -> Analytic {
+ let size = self.size_hint().max(1e-9);
+ let iso = |k: usize, x: f64| -> C3 {
+ let n = 24;
+ let pts = (0..=n)
+ .map(|i| {
+ let t = self.dom[k][0] + (self.dom[k][1] - self.dom[k][0]) * i as f64 / n as f64;
+ if k == 0 { self.point([t, x]) } else { self.point([x, t]) }
+ })
+ .collect();
+ C3::Polyline(pts)
+ };
+ let straight = |c: &C3| {
+ let C3::Polyline(p) = c else { return false };
+ let (Some(a), Some(b)) = (p.first(), p.last()) else { return false };
+ let Some(e) = (*b - *a).normalized() else { return false };
+ p.iter().all(|q| ((*q - *a) - e * (*q - *a).dot(e)).len() <= tol * size)
+ };
+ let circle_of = |k: usize, x: f64| -> Option<(Vec3, Vec3, f64)> {
+ // Fit through exact surface points, then verify densely.
+ let at = |f: f64| {
+ let t = self.dom[k][0] + (self.dom[k][1] - self.dom[k][0]) * f;
+ if k == 0 { self.point([t, x]) } else { self.point([x, t]) }
+ };
+ let pts: Vec<Vec3> = (0..=32).map(|i| at(i as f64 / 32.)).collect();
+ let sp = C3::Polyline(pts.clone());
+ let (a, m, b) = (pts.first().copied()?, pts.get(16).copied()?, pts.get(8).copied()?);
+ let (u, v) = (m - a, b - a);
+ let n = u.cross(v);
+ let n2 = n.len2();
+ // Nearly collinear relative to the points' own spacing.
+ if n2 <= 1e-24 * u.len2() * v.len2() {
+ return None;
+ }
+ let c = a + (v * u.len2() - u * v.len2()).cross(n) * (1. / (2. * n2));
+ let nn = n.normalized()?;
+ let r = c.dist(a);
+ let ok = match &sp {
+ C3::Polyline(p) => p.iter().all(|q| (q.dist(c) - r).abs() <= tol * r && (*q - c).dot(nn).abs() <= tol * r),
+ _ => false,
+ };
+ ok.then_some((c, nn, r))
+ };
+ for (line_dir, circ_dir) in [(1usize, 0usize), (0, 1)] {
+ let mids = [0., 0.5, 1.].map(|f| self.dom[circ_dir][0] + (self.dom[circ_dir][1] - self.dom[circ_dir][0]) * f);
+ if !mids.iter().all(|x| straight(&iso(line_dir, *x))) {
+ continue;
+ }
+ let ends = [0., 0.5, 1.].map(|f| self.dom[line_dir][0] + (self.dom[line_dir][1] - self.dom[line_dir][0]) * f);
+ let circles: Option<Vec<_>> = ends.iter().map(|x| circle_of(circ_dir, *x)).collect();
+ let Some(circles) = circles else { continue };
+ let (Some(c0), Some(c2)) = (circles.first(), circles.last()) else { continue };
+ let Some(axis) = (c2.0 - c0.0).normalized() else { continue };
+ if c0.1.cross(axis).len() > tol {
+ continue;
+ }
+ if (c0.2 - c2.2).abs() <= tol * c0.2 {
+ return Analytic::Cylinder { p: c0.0, a: axis, r: c0.2 };
+ }
+ let dr = (c2.2 - c0.2) / c0.0.dist(c2.0);
+ let half = dr.abs().atan();
+ let dir = if dr > 0. { axis } else { -axis };
+ let apex = c0.0 - dir * (c0.2 / dr.abs());
+ return Analytic::Cone { apex, a: dir, half };
+ }
+ // Sphere: every grid point equidistant from the centre of four spread points. Several
+ // spreads are tried: on a patch closed around (a full band) the corners meet at its seam.
+ let g = self.g;
+ let pick = |i: usize, j: usize| self.grid.get(j * (g + 1) + i).copied();
+ let spreads = [
+ [(0, 0), (g, 0), (g / 2, g / 2), (0, g)],
+ [(0, 0), (g / 2, 0), (g / 4, g), (3 * g / 4, g / 2)],
+ [(g / 3, 0), (0, g / 2), (2 * g / 3, g), (g, g / 3)],
+ ];
+ for q in spreads {
+ let (Some(a), Some(b), Some(c), Some(d)) = (pick(q[0].0, q[0].1), pick(q[1].0, q[1].1), pick(q[2].0, q[2].1), pick(q[3].0, q[3].1))
+ else {
+ continue;
+ };
+ let Some(centre) = sphere_centre(a, b, c, d) else { continue };
+ let r = centre.dist(a);
+ if r > 0. && self.grid.iter().all(|p| (p.dist(centre) - r).abs() <= tol * r) {
+ return Analytic::Sphere { c: centre, r };
+ }
+ }
+ // Torus: circles both ways, a meridian giving the tube's centre and radius and a
+ // parallel the axis; then every grid point on that torus.
+ let mid = |k: usize| self.dom.get(k).map_or(0., |d| 0.5 * (d[0] + d[1]));
+ for (meridian, parallel) in [(0usize, 1usize), (1, 0)] {
+ let (Some(m), Some(p)) = (circle_of(meridian, mid(parallel)), circle_of(parallel, mid(meridian))) else { continue };
+ let (a, minor) = (p.1, m.2);
+ let c = p.0 + a * (m.0 - p.0).dot(a);
+ let major = m.0.dist(c);
+ if !(major > 0. && minor > 0.) {
+ continue;
+ }
+ let on = self.grid.iter().all(|q| {
+ let w = *q - c;
+ let h = w.dot(a);
+ (((w - a * h).len() - major).hypot(h) - minor).abs() <= tol * (major + minor)
+ });
+ if on {
+ return Analytic::Torus { c, a, major, minor };
+ }
+ }
+ Analytic::Other
+ }
+}
+
+fn sphere_centre(a: Vec3, b: Vec3, c: Vec3, d: Vec3) -> Option<Vec3> {
+ // Solve 2(p_i - a).x = |p_i|^2 - |a|^2 for i = b, c, d.
+ let rows = [b - a, c - a, d - a];
+ let rhs = [b.len2() - a.len2(), c.len2() - a.len2(), d.len2() - a.len2()].map(|v| v * 0.5);
+ let [r0, r1, r2] = rows;
+ let det = r0.dot(r1.cross(r2));
+ if det.abs() <= 1e-18 * (1. + r0.len() * r1.len() * r2.len()) {
+ return None;
+ }
+ let x = (r1.cross(r2) * rhs[0] + r2.cross(r0) * rhs[1] + r0.cross(r1) * rhs[2]) / det;
+ x.is_finite().then_some(x)
+}
diff --git a/crates/geom/src/hlr/trim.rs b/crates/geom/src/hlr/trim.rs
new file mode 100644
index 0000000000..c416d33190
--- /dev/null
+++ b/crates/geom/src/hlr/trim.rs
@@ -0,0 +1,382 @@
+//! Face trimming in the surface chart. Boundary loops are sampled from the exact edge curves,
+//! unwrapped across periodic directions, and a point is classified by the parity of boundary
+//! crossings on a path to a point known to be inside. Seams (an edge used twice by one face)
+//! are crossed twice, so they cancel without special cases.
+
+use super::curve::C3;
+use super::surface::S3;
+use crate::Vec3;
+use crate::brep::Face;
+
+#[derive(Clone, Debug)]
+pub(crate) struct Trim {
+ /// Unwrapped chart segments of all loops.
+ segs: Vec<([f64; 2], [f64; 2])>,
+ period: [Option<f64>; 2],
+ /// A point inside the face; `None` when the face covers its whole chart.
+ inside: Option<[f64; 2]>,
+ /// 3D boundary chords, for distance-to-boundary margins.
+ pub chords: Vec<(Vec3, Vec3)>,
+ /// Largest distance between an exact boundary curve and its chords.
+ pub chord_error: f64,
+ pub lo: Vec3,
+ pub hi: Vec3,
+ /// Why classification is unavailable, if it is.
+ pub unsupported: Option<&'static str>,
+ /// Index for the two-leg parity path q -> (r.u, q.v) -> r.
+ index: Option<Index>,
+ /// `chords` on a grid, for boundaries with many of them.
+ grid: Option<ChordGrid>,
+}
+
+/// Boundary chords bucketed on a uniform grid over the boundary's box, so a point is checked
+/// against the chords around it, not all of them (a circle alone has `trim_samples` per break).
+/// Cells are at least as long as the longest chord, so a chord lies in at most two per axis.
+#[derive(Clone, Debug)]
+struct ChordGrid {
+ lo: Vec3,
+ cell: f64,
+ n: [usize; 3],
+ /// (cell, chord) pairs sorted by cell.
+ entries: Vec<(u32, u32)>,
+}
+
+impl ChordGrid {
+ fn new(chords: &[(Vec3, Vec3)], lo: Vec3, hi: Vec3) -> Option<ChordGrid> {
+ // A few chords are checked faster one by one than through a grid.
+ if chords.len() < 64 || u32::try_from(chords.len()).is_err() {
+ return None;
+ }
+ let ext = hi - lo;
+ let longest = chords.iter().map(|(a, b)| a.dist(*b)).fold(0., f64::max);
+ let cell = longest.max(ext.len() / 256.).max(ext.x.max(ext.y).max(ext.z) / 512.);
+ if !(cell > 0. && cell.is_finite()) {
+ return None;
+ }
+ let n = [ext.x, ext.y, ext.z].map(|e| ((e / cell).floor() as usize).saturating_add(1).min(513));
+ let mut grid = ChordGrid { lo, cell, n, entries: Vec::with_capacity(chords.len() * 2) };
+ for (i, (a, b)) in (0u32..).zip(chords) {
+ let (c0, c1) = (grid.cell_of(a.min(*b)), grid.cell_of(a.max(*b)));
+ for x in c0[0]..=c1[0] {
+ for y in c0[1]..=c1[1] {
+ for z in c0[2]..=c1[2] {
+ grid.entries.push((grid.key([x, y, z]), i));
+ }
+ }
+ }
+ }
+ grid.entries.sort_unstable();
+ Some(grid)
+ }
+
+ fn cell_of(&self, p: Vec3) -> [usize; 3] {
+ let at = |v: f64, l: f64, n: usize| (((v - l) / self.cell).floor().max(0.) as usize).min(n.saturating_sub(1));
+ [at(p.x, self.lo.x, self.n[0]), at(p.y, self.lo.y, self.n[1]), at(p.z, self.lo.z, self.n[2])]
+ }
+
+ fn key(&self, c: [usize; 3]) -> u32 {
+ // At most 513 cells per axis: the key fits in 28 bits.
+ ((c[0] * self.n[1] + c[1]) * self.n[2] + c[2]) as u32
+ }
+
+ /// Whether a chord touching a cell of the box `p` +- `tol` is within `tol` of `p`; `None`
+ /// when that box covers too many cells to be worth it.
+ fn near(&self, chords: &[(Vec3, Vec3)], p: Vec3, tol: f64) -> Option<bool> {
+ // A little wider than `tol`, so rounding in the distance cannot pick a chord whose
+ // nearest point lies in a cell left out.
+ let w = tol * (1. + 1e-6);
+ let t = Vec3::new(w, w, w);
+ let (c0, c1) = (self.cell_of(p - t), self.cell_of(p + t));
+ let span = |k: usize| c1[k].saturating_sub(c0[k]).saturating_add(1);
+ if span(0).saturating_mul(span(1)).saturating_mul(span(2)) > 64 {
+ return None;
+ }
+ for x in c0[0]..=c1[0] {
+ for y in c0[1]..=c1[1] {
+ for z in c0[2]..=c1[2] {
+ let k = self.key([x, y, z]);
+ let first = self.entries.partition_point(|e| e.0 < k);
+ let close = self
+ .entries
+ .get(first..)
+ .unwrap_or_default()
+ .iter()
+ .take_while(|e| e.0 == k)
+ .any(|(_, i)| chords.get(*i as usize).is_some_and(|(a, b)| p.dist_to_segment(*a, *b) <= tol));
+ if close {
+ return Some(true);
+ }
+ }
+ }
+ }
+ Some(false)
+ }
+}
+
+/// Segment copies shifted across periods near the inside point, the sorted crossings of the
+/// vertical line u = r.u, and v-buckets of the copies for the horizontal leg.
+#[derive(Clone, Debug)]
+struct Index {
+ copies: Vec<([f64; 2], [f64; 2])>,
+ vcross: Vec<f64>,
+ buckets: Vec<Vec<u32>>,
+ v0: f64,
+ dv: f64,
+}
+
+fn spans(x: f64, a: f64, b: f64) -> bool {
+ (a <= x && x < b) || (b <= x && x < a)
+}
+
+fn index(segs: &[([f64; 2], [f64; 2])], period: [Option<f64>; 2], r: [f64; 2]) -> Index {
+ let shifts = |k: usize| -> Vec<f64> {
+ let Some(p) = period[k] else { return vec![0.] };
+ let (lo, hi) = segs.iter().fold((f64::MAX, f64::MIN), |(lo, hi), (a, b)| (lo.min(a[k]).min(b[k]), hi.max(a[k]).max(b[k])));
+ let k0 = ((r[k] - p - hi) / p).floor() as i64;
+ let k1 = ((r[k] + p - lo) / p).ceil() as i64;
+ (k0.max(-8)..=k1.min(8)).map(|i| i as f64 * p).collect()
+ };
+ let mut copies = Vec::new();
+ for dx in shifts(0) {
+ for dy in shifts(1) {
+ copies.extend(segs.iter().map(|(a, b)| ([a[0] + dx, a[1] + dy], [b[0] + dx, b[1] + dy])));
+ }
+ }
+ let mut vcross: Vec<f64> =
+ copies.iter().filter(|(a, b)| spans(r[0], a[0], b[0])).map(|(a, b)| a[1] + (b[1] - a[1]) * (r[0] - a[0]) / (b[0] - a[0])).collect();
+ vcross.sort_by(f64::total_cmp);
+ let (v0, v1) = copies.iter().fold((f64::MAX, f64::MIN), |(lo, hi), (a, b)| (lo.min(a[1]).min(b[1]), hi.max(a[1]).max(b[1])));
+ let n = ((copies.len() as f64).sqrt().ceil() as usize).clamp(1, 4096);
+ let dv = ((v1 - v0) / n as f64).max(1e-300);
+ let mut buckets = vec![Vec::new(); n];
+ for (i, (a, b)) in copies.iter().enumerate() {
+ let k0 = (((a[1].min(b[1]) - v0) / dv).floor().max(0.) as usize).min(n - 1);
+ let k1 = (((a[1].max(b[1]) - v0) / dv).floor().max(0.) as usize).min(n - 1);
+ for bucket in buckets.iter_mut().take(k1 + 1).skip(k0) {
+ bucket.push(i as u32);
+ }
+ }
+ Index { copies, vcross, buckets, v0, dv }
+}
+
+fn lift(x: f64, near: f64, p: Option<f64>) -> f64 {
+ match p {
+ Some(p) if p > 0. => x + p * ((near - x) / p).round(),
+ _ => x,
+ }
+}
+
+pub(crate) fn build(face: &Face, edges: &[C3], surface: &S3, per_break: usize) -> Trim {
+ let period = surface.periods();
+ let mut segs = Vec::new();
+ let mut seam = Vec::new();
+ let mut chords = Vec::new();
+ let mut chord_error = 0f64;
+ let (mut lo, mut hi) = (Vec3::new(f64::MAX, f64::MAX, f64::MAX), Vec3::new(f64::MIN, f64::MIN, f64::MIN));
+ let mut uses = std::collections::BTreeMap::new();
+ for u in face.loops.iter().flatten() {
+ *uses.entry(u.edge).or_insert(0usize) += 1;
+ }
+ let mut area_u = 0.; // -loop integral of v du
+ let mut area_v = 0.; // loop integral of u dv
+ let mut wraps = [false; 2];
+ let mut unsupported = None;
+ for lp in &face.loops {
+ let mut pts: Vec<([f64; 2], bool)> = Vec::new();
+ let mut hint: Option<[f64; 2]> = None;
+ for u in lp {
+ let Some(c) = edges.get(u.edge as usize) else {
+ unsupported = Some("edge reference");
+ continue;
+ };
+ let is_seam = uses.get(&u.edge).copied().unwrap_or(0) > 1;
+ let mut ts = Vec::new();
+ let b = c.breaks();
+ for w in b.windows(2) {
+ let (Some(t0), Some(t1)) = (w.first(), w.get(1)) else { continue };
+ for i in 0..per_break {
+ ts.push(t0 + (t1 - t0) * i as f64 / per_break as f64);
+ }
+ }
+ if let Some(last) = b.last() {
+ ts.push(*last);
+ }
+ if !u.forward {
+ ts.reverse();
+ }
+ let mut prev3: Option<(f64, Vec3)> = None;
+ for t in ts {
+ let p = c.at(t);
+ lo = lo.min(p);
+ hi = hi.max(p);
+ if let Some((tp, q)) = prev3 {
+ chords.push((q, p));
+ let m = c.at(0.5 * (t + tp));
+ chord_error = chord_error.max(m.dist_to_segment(q, p));
+ }
+ prev3 = Some((t, p));
+ let Some(mut uv) = surface.inverse(p, hint) else {
+ unsupported = Some("boundary point off its surface");
+ continue;
+ };
+ if let Some(h) = hint {
+ uv = [lift(uv[0], h[0], period[0]), lift(uv[1], h[1], period[1])];
+ }
+ hint = Some(uv);
+ pts.push((uv, is_seam));
+ }
+ }
+ let (Some(first), Some(last)) = (pts.first().copied(), pts.last().copied()) else { continue };
+ // Close the loop at the lifted copy of its start (a wrapping loop ends a period away).
+ let close = [lift(first.0[0], last.0[0], period[0]), lift(first.0[1], last.0[1], period[1])];
+ for k in 0..2 {
+ if (close[k] - first.0[k]).abs() > 1e-9 {
+ wraps[k] = true;
+ }
+ }
+ pts.push((close, last.1));
+ for w in pts.windows(2) {
+ let (Some((a, _)), Some((b, s))) = (w.first(), w.get(1)) else { continue };
+ area_u -= 0.5 * (a[1] + b[1]) * (b[0] - a[0]);
+ area_v += 0.5 * (a[0] + b[0]) * (b[1] - a[1]);
+ segs.push((*a, *b));
+ seam.push(*s);
+ }
+ }
+ let area = match wraps {
+ [true, true] => {
+ unsupported = unsupported.or(Some("loops wrap in both chart directions"));
+ 0.
+ }
+ [false, true] => area_v,
+ _ => area_u,
+ };
+ // Loops that wind once around a periodic direction without coming back (a hemisphere's
+ // equator) close against the chart's own edge, so their area depends on where the chart
+ // starts: there the face is taken on the loops' left (the B-rep convention), and below the
+ // side within the surface's domain wins either way.
+ let net = segs.iter().fold([0f64; 2], |n, (a, b)| [n[0] + b[0] - a[0], n[1] + b[1] - a[1]]);
+ let open = (0..2).any(|k| period[k].is_some_and(|p| net[k].abs() > 0.5 * p));
+ let sigma = if open { 1. } else { area.signum() };
+ let dom = surface.domain();
+ // Inside point: beside the longest non-seam segment, on the face's side.
+ let mut inside = None;
+ let real: Vec<usize> = (0..segs.len()).filter(|i| !seam.get(*i).copied().unwrap_or(true)).collect();
+ if !real.is_empty() && (open || area != 0.) {
+ let len = |i: usize| segs.get(i).map_or(0., |(a, b)| ((b[0] - a[0]).powi(2) + (b[1] - a[1]).powi(2)).sqrt());
+ let best = real.iter().copied().max_by(|a, b| len(*a).total_cmp(&len(*b)));
+ if let Some((a, b)) = best.and_then(|i| segs.get(i)) {
+ let m = [0.5 * (a[0] + b[0]), 0.5 * (a[1] + b[1])];
+ let l = ((b[0] - a[0]).powi(2) + (b[1] - a[1]).powi(2)).sqrt();
+ let n = [-(b[1] - a[1]) / l * sigma, (b[0] - a[0]) / l * sigma];
+ // Stay well inside: a quarter of the distance to any other boundary piece.
+ let mut room = l;
+ for (j, (c, e)) in segs.iter().enumerate() {
+ if Some(j) == best {
+ continue;
+ }
+ for (dx, dy) in shifts(period) {
+ let (c2, e2) = ([c[0] + dx, c[1] + dy], [e[0] + dx, e[1] + dy]);
+ room = room.min(point_segment(m, c2, e2));
+ }
+ }
+ let delta = 0.25 * room;
+ // At most half way to the chart's domain edge, so a face hugging that edge (a cone's
+ // tip) keeps its point; a loop on the edge itself has no room on the outer side.
+ let step = |dir: [f64; 2]| {
+ let mut s = delta;
+ for (((d, &c), &mk), p) in dom.iter().zip(&dir).zip(&m).zip(&period) {
+ if p.is_some() {
+ continue;
+ }
+ if c < 0. {
+ s = s.min(0.5 * (mk - d[0]) / -c);
+ } else if c > 0. {
+ s = s.min(0.5 * (d[1] - mk) / c);
+ }
+ }
+ s
+ };
+ let flip = [-n[0], -n[1]];
+ let pick = [(n, step(n)), (flip, step(flip))].into_iter().find(|(_, s)| *s > 0. && s.is_finite());
+ if let Some((dir, s)) = pick {
+ inside = Some([m[0] + dir[0] * s, m[1] + dir[1] * s]);
+ }
+ }
+ if inside.is_none() {
+ unsupported = unsupported.or(Some("no room for an inside reference point"));
+ }
+ }
+ let index = inside.map(|r| index(&segs, period, r));
+ let grid = ChordGrid::new(&chords, lo, hi);
+ Trim { segs, period, inside, chords, chord_error, lo, hi, unsupported, index, grid }
+}
+
+fn shifts(period: [Option<f64>; 2]) -> Vec<(f64, f64)> {
+ let ks = |p: Option<f64>| p.map_or(vec![0.], |p| vec![-p, 0., p]);
+ let mut out = Vec::new();
+ for dx in ks(period[0]) {
+ for dy in ks(period[1]) {
+ out.push((dx, dy));
+ }
+ }
+ out
+}
+
+fn point_segment(p: [f64; 2], a: [f64; 2], b: [f64; 2]) -> f64 {
+ let (ex, ey) = (b[0] - a[0], b[1] - a[1]);
+ let l2 = ex * ex + ey * ey;
+ let t = if l2 > 0. { (((p[0] - a[0]) * ex + (p[1] - a[1]) * ey) / l2).clamp(0., 1.) } else { 0. };
+ ((a[0] + t * ex - p[0]).powi(2) + (a[1] + t * ey - p[1]).powi(2)).sqrt()
+}
+
+impl Trim {
+ /// Whether chart point `uv` lies inside the face; `None` when the trim is unsupported.
+ /// Parity of boundary crossings on the path q -> (r.u, q.v) -> r to the inside point r.
+ pub fn contains(&self, uv: [f64; 2]) -> Option<bool> {
+ if self.unsupported.is_some() {
+ return None;
+ }
+ let (Some(r), Some(ix)) = (self.inside, self.index.as_ref()) else { return Some(true) };
+ let q = [lift(uv[0], r[0], self.period[0]), lift(uv[1], r[1], self.period[1])];
+ let mut crossings = 0usize;
+ // Horizontal leg at v = q.v between q.u and r.u.
+ let (ulo, uhi) = (q[0].min(r[0]), q[0].max(r[0]));
+ let k = (((q[1] - ix.v0) / ix.dv).floor().max(0.) as usize).min(ix.buckets.len().saturating_sub(1));
+ for i in ix.buckets.get(k).map(Vec::as_slice).unwrap_or(&[]) {
+ let Some((a, b)) = ix.copies.get(*i as usize) else { continue };
+ if spans(q[1], a[1], b[1]) {
+ let u = a[0] + (b[0] - a[0]) * (q[1] - a[1]) / (b[1] - a[1]);
+ if u > ulo && u <= uhi {
+ crossings += 1;
+ }
+ }
+ }
+ // Vertical leg at u = r.u between q.v and r.v.
+ let (vlo, vhi) = (q[1].min(r[1]), q[1].max(r[1]));
+ let first = ix.vcross.partition_point(|v| *v <= vlo);
+ let last = ix.vcross.partition_point(|v| *v <= vhi);
+ crossings += last.saturating_sub(first);
+ Some(crossings.is_multiple_of(2))
+ }
+
+ /// The chart box of the unwrapped boundary.
+ pub fn uv_bounds(&self) -> Option<([f64; 2], [f64; 2])> {
+ let mut it = self.segs.iter().flat_map(|(a, b)| [a, b]);
+ let first = *it.next()?;
+ Some(it.fold((first, first), |(lo, hi), p| ([lo[0].min(p[0]), lo[1].min(p[1])], [hi[0].max(p[0]), hi[1].max(p[1])])))
+ }
+
+ /// Whether a 3D point is within `tol` of the sampled boundary: the boundary's box first,
+ /// then the chords around the point (all of them for a short boundary or a wide `tol`).
+ pub fn near(&self, p: Vec3, tol: f64) -> bool {
+ let out = (self.lo - p).max(p - self.hi).max(Vec3::new(0., 0., 0.));
+ if !(out.len() <= tol) {
+ return false;
+ }
+ match self.grid.as_ref().and_then(|g| g.near(&self.chords, p, tol)) {
+ Some(close) => close,
+ None => self.chords.iter().any(|(a, b)| p.dist_to_segment(*a, *b) <= tol),
+ }
+ }
+}
diff --git a/crates/geom/src/hlr_tests.rs b/crates/geom/src/hlr_tests.rs
new file mode 100644
index 0000000000..d56729e3d9
--- /dev/null
+++ b/crates/geom/src/hlr_tests.rs
@@ -0,0 +1,2213 @@
+use super::*;
+use crate::brep::{Brep, Curve, Edge, EdgeUse, Face, Shell, Surface};
+
+/// An axis-aligned box with line edges and plane faces.
+fn cuboid(lo: [f64; 3], hi: [f64; 3]) -> Brep {
+ let corner = |i: usize| [if i & 1 == 0 { lo[0] } else { hi[0] }, if i & 2 == 0 { lo[1] } else { hi[1] }, if i & 4 == 0 { lo[2] } else { hi[2] }];
+ let vertices: Vec<[f64; 3]> = (0..8).map(corner).collect();
+ let pairs = [(0, 1), (2, 3), (4, 5), (6, 7), (0, 2), (1, 3), (4, 6), (5, 7), (0, 4), (1, 5), (2, 6), (3, 7)];
+ let edges: Vec<Edge> =
+ pairs.iter().map(|&(a, b)| Edge { vertices: [a as u32, b as u32], curve: Curve::Line { start: corner(a), end: corner(b) } }).collect();
+ let cycle = |vs: [usize; 4]| -> Vec<EdgeUse> {
+ (0..4)
+ .map(|k| {
+ let (a, b) = (vs[k], vs[(k + 1) % 4]);
+ let (i, fwd) = pairs
+ .iter()
+ .enumerate()
+ .find_map(|(i, &(x, y))| (x == a && y == b).then_some((i, true)).or((x == b && y == a).then_some((i, false))))
+ .unwrap();
+ EdgeUse { edge: i as u32, forward: fwd }
+ })
+ .collect()
+ };
+ let plane = |o: usize, u: usize, v: usize| {
+ let (o, u, v) = (corner(o), corner(u), corner(v));
+ Surface::Plane { origin: o, u_axis: [u[0] - o[0], u[1] - o[1], u[2] - o[2]], v_axis: [v[0] - o[0], v[1] - o[1], v[2] - o[2]] }
+ };
+ let faces = vec![
+ Face { loops: vec![cycle([0, 2, 3, 1])], surface: plane(0, 2, 1), forward: true },
+ Face { loops: vec![cycle([4, 5, 7, 6])], surface: plane(4, 5, 6), forward: true },
+ Face { loops: vec![cycle([0, 1, 5, 4])], surface: plane(0, 1, 4), forward: true },
+ Face { loops: vec![cycle([2, 6, 7, 3])], surface: plane(2, 6, 3), forward: true },
+ Face { loops: vec![cycle([0, 4, 6, 2])], surface: plane(0, 4, 2), forward: true },
+ Face { loops: vec![cycle([1, 3, 7, 5])], surface: plane(1, 3, 5), forward: true },
+ ];
+ Brep { version: crate::brep::VERSION, shells: vec![Shell { vertices, edges, faces }] }
+}
+
+fn identity(body: usize, t: [f64; 3]) -> Placement {
+ Placement { body, rotation: [Vec3::new(1., 0., 0.), Vec3::new(0., 1., 0.), Vec3::new(0., 0., 1.)], translation: Vec3::new(t[0], t[1], t[2]) }
+}
+
+fn never() -> bool {
+ false
+}
+
+#[test]
+fn iso_cube_hides_the_three_back_edges() {
+ let def = prepare(&cuboid([0.; 3], [1.; 3]), &Options::default()).unwrap();
+ let view = View::new(Vec3::new(-1., -1., -1.), Vec3::new(0., 0., 1.)).unwrap();
+ let d = hidden_lines(&[def], &[identity(0, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ let mut hidden = Vec::new();
+ for l in &d.lines {
+ let Source::Edge { edge, .. } = l.source else { panic!("a box has no silhouettes") };
+ let states: Vec<_> = l.pieces.iter().map(|p| p.visibility).collect();
+ assert!(states.windows(2).all(|w| w[0] == w[1]), "edge {edge} is split: {states:?}");
+ if states[0] == Visibility::Hidden {
+ hidden.push(edge);
+ }
+ }
+ hidden.sort_unstable();
+ // The edges at the corner nearest the origin: (0,1), (0,2), (0,4).
+ assert_eq!(hidden, vec![0, 4, 8], "{d:#?}");
+}
+
+#[test]
+fn a_box_in_front_hides_the_middle_of_an_edge() {
+ let back = prepare(&cuboid([0.; 3], [1.; 3]), &Options::default()).unwrap();
+ let front = prepare(&cuboid([0.5, -2., 0.25], [1.5, -1., 0.75]), &Options::default()).unwrap();
+ let view = View::new(Vec3::new(0., 1., 0.), Vec3::new(0., 0., 1.)).unwrap();
+ let d = hidden_lines(&[back, front], &[identity(0, [0.; 3]), identity(1, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ // Edge 9 joins corners 1 (1,0,0) and 5 (1,0,1): t is z.
+ let line = d.lines.iter().find(|l| l.placement == 0 && l.source == Source::Edge { edge: 9, tangent: false }).unwrap();
+ let got: Vec<([f64; 2], Visibility)> = line.pieces.iter().map(|p| (p.t, p.visibility)).collect();
+ assert_eq!(got.len(), 3, "{got:?}");
+ assert_eq!(got[1].1, Visibility::Hidden);
+ assert!((got[1].0[0] - 0.25).abs() < 1e-12 && (got[1].0[1] - 0.75).abs() < 1e-12, "{got:?}");
+ assert_eq!((got[0].1, got[2].1), (Visibility::Visible, Visibility::Visible));
+}
+
+#[test]
+fn quadratic_roots_with_no_linear_term() {
+ // A ray from inside a sphere, square to the radius at its start (b = 0): both roots.
+ let mut roots = surface::quadratic(1., 0., -100.);
+ roots.sort_by(|a, b| a.0.total_cmp(&b.0));
+ assert_eq!(roots.len(), 2, "{roots:?}");
+ assert!((roots[0].0 + 10.).abs() < 1e-12 && (roots[1].0 - 10.).abs() < 1e-12, "{roots:?}");
+ let mut roots = surface::quadratic(1., -0., -100.);
+ roots.sort_by(|a, b| a.0.total_cmp(&b.0));
+ assert!((roots[0].0 + 10.).abs() < 1e-12 && (roots[1].0 - 10.).abs() < 1e-12, "{roots:?}");
+}
+
+#[test]
+fn a_torus_seen_along_its_axis_has_both_equator_silhouettes() {
+ // A whole-meridian torus record: the outer equator sits where the closed profile's ends meet.
+ let frame = crate::brep::Frame { origin: [0.; 3], x_axis: [1., 0., 0.], y_axis: [0., 1., 0.] };
+ let tau = std::f64::consts::TAU;
+ let s = surface::S3::new(&Surface::Torus { frame, major_radius: 20., minor_radius: 5., longitude: [0., tau], meridian: [0., tau] }).unwrap();
+ let mut radii: Vec<f64> = s
+ .rev_silhouette(Vec3::new(0., 0., -1.))
+ .iter()
+ .map(|(c, _)| match c {
+ curve::C3::Arc { r, .. } => r[0],
+ _ => panic!("circles expected"),
+ })
+ .collect();
+ radii.sort_by(f64::total_cmp);
+ assert_eq!(radii.len(), 2, "{radii:?}");
+ assert!((radii[0] - 15.).abs() < 1e-9 && (radii[1] - 25.).abs() < 1e-9, "{radii:?}");
+}
+
+#[test]
+fn far_apart_bodies_do_not_merge_nearby_visible_edges() {
+ // A 5 mm cube and a box 100 m away: coincidence is judged at the chords' own accuracy,
+ // not at a fraction of the scene's size, so none of the cube's edges is taken as a duplicate.
+ let near = prepare(&cuboid([0.; 3], [5.; 3]), &Options::default()).unwrap();
+ let far = prepare(&cuboid([100_000.; 3], [100_001.; 3]), &Options::default()).unwrap();
+ let view = View::new(Vec3::new(-1., -0.7, -0.4), Vec3::new(0., 0., 1.)).unwrap();
+ let d = hidden_lines(&[near, far], &[identity(0, [0.; 3]), identity(1, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ let covered_visible = d
+ .lines
+ .iter()
+ .filter(|l| l.placement == 0)
+ .flat_map(|l| l.pieces.iter())
+ .filter(|p| p.visibility == Visibility::Visible && p.covered)
+ .count();
+ assert_eq!(covered_visible, 0);
+}
+
+#[test]
+fn a_thin_torus_tube_stops_a_ray() {
+ // R 100, r 0.1: a ray across the tube meets it twice within 0.2 mm.
+ let roots = surface::torus_roots(Vec3::new(100., -50., 0.), Vec3::new(0., 1., 0.), Vec3::new(0., 0., 1.), 100., 0.1, [0., 200.]);
+ assert!(roots.iter().filter(|(_, grazing)| !grazing).count() >= 2, "{roots:?}");
+}
+
+#[test]
+fn a_thin_tube_on_a_huge_torus_stops_a_ray() {
+ // R 100 m, r 1 mm: inside the tube the implicit function stays far below a size^4 floor.
+ // A radial ray from 5 mm inside the centre circle crosses the tube at 4 and 6 mm.
+ let roots = surface::torus_roots(Vec3::new(100_000. - 5., 0., 0.), Vec3::new(1., 0., 0.), Vec3::new(0., 0., 1.), 100_000., 1., [0., 10.]);
+ let hits: Vec<f64> = roots.iter().filter(|(_, grazing)| !grazing).map(|(l, _)| *l).collect();
+ // The implicit form cancels terms of 4e20 here: the roots are good to about 1e-6 mm.
+ assert!(hits.len() == 2 && (hits[0] - 4.).abs() < 1e-5 && (hits[1] - 6.).abs() < 1e-5, "{roots:?}");
+}
+
+#[test]
+fn a_hair_thin_tube_on_a_kilometre_torus_stops_a_ray() {
+ // R 1 km, r 0.1 mm (R/r = 1e7): roots at 0.9 and 1.1 mm, good to about 1e-4 mm here.
+ let roots = surface::torus_roots(Vec3::new(1e6 - 1., 0., 0.), Vec3::new(1., 0., 0.), Vec3::new(0., 0., 1.), 1e6, 0.1, [0., 2.]);
+ let hits: Vec<f64> = roots.iter().filter(|(_, grazing)| !grazing).map(|(l, _)| *l).collect();
+ assert!(hits.len() == 2 && (hits[0] - 0.9).abs() < 1e-3 && (hits[1] - 1.1).abs() < 1e-3, "{roots:?}");
+}
+
+#[test]
+fn a_ray_from_the_hole_crosses_a_thin_large_torus() {
+ // R 4 m, r 0.01 mm, from the centre outward over 8 m: only the shell around the tube is sampled.
+ let roots = surface::torus_roots(Vec3::new(0., 0., 0.), Vec3::new(1., 0., 0.), Vec3::new(0., 0., 1.), 4000., 0.01, [0., 8000.]);
+ let hits: Vec<f64> = roots.iter().filter(|(_, grazing)| !grazing).map(|(l, _)| *l).collect();
+ assert!(hits.len() == 2 && (hits[0] - 3999.99).abs() < 1e-6 && (hits[1] - 4000.01).abs() < 1e-6, "{roots:?}");
+}
+
+#[test]
+fn a_torus_seen_nearly_along_its_axis_keeps_its_silhouettes() {
+ // Meridian starting off the equator and a view 1e-4 rad from the axis: the silhouette lives
+ // in narrow profile intervals around the equators, which must not fall between samples.
+ let frame = crate::brep::Frame { origin: [0.; 3], x_axis: [1., 0., 0.], y_axis: [0., 1., 0.] };
+ let tau = std::f64::consts::TAU;
+ let shift = std::f64::consts::PI / 720.;
+ let s =
+ surface::S3::new(&Surface::Torus { frame, major_radius: 1000., minor_radius: 500., longitude: [0., tau], meridian: [shift, shift + tau] })
+ .unwrap();
+ let d = Vec3::new(1e-4, 0., -1.).normalized().unwrap();
+ let curves = s.rev_silhouette(d);
+ // Both the outer (radius about 1500) and the inner (about 500) silhouettes are there.
+ let radii: Vec<f64> = curves
+ .iter()
+ .flat_map(|(c, _)| {
+ let [t0, t1] = c.domain();
+ (0..=8).map(move |i| c.at(t0 + (t1 - t0) * i as f64 / 8.))
+ })
+ .map(|p| p.x.hypot(p.y))
+ .collect();
+ assert!(radii.iter().any(|r| *r > 1400.) && radii.iter().any(|r| *r < 600.), "{radii:?}");
+}
+
+#[test]
+fn a_shallow_cut_through_a_torus_tube_is_found() {
+ // R 20, r 5, a ray along the axis 0.01 mm inside the outer equator: a 0.63 mm chord.
+ let roots = surface::torus_roots(Vec3::new(24.99, 0., -10.), Vec3::new(0., 0., 1.), Vec3::new(0., 0., 1.), 20., 5., [0., 20.]);
+ let hits: Vec<f64> = roots.iter().filter(|(_, grazing)| !grazing).map(|(l, _)| *l).collect();
+ let half = (25f64 - 4.99f64.powi(2)).sqrt();
+ assert!(hits.len() == 2 && (hits[0] - (10. - half)).abs() < 1e-6 && (hits[1] - (10. + half)).abs() < 1e-6, "{roots:?}");
+}
+
+/// A frame at `o` with x along +X and y along +Y (z along +Z).
+fn frame_at(o: [f64; 3]) -> crate::brep::Frame {
+ crate::brep::Frame { origin: o, x_axis: [1., 0., 0.], y_axis: [0., 1., 0.] }
+}
+
+/// A full circle about Z through vertex `v`.
+fn circle(o: [f64; 3], r: f64, v: u32) -> Edge {
+ Edge { vertices: [v, v], curve: Curve::CircleArc { frame: frame_at(o), radius: r, angle: [0., std::f64::consts::TAU] } }
+}
+
+fn uses(edge: u32, forward: bool) -> EdgeUse {
+ EdgeUse { edge, forward }
+}
+
+/// A cylinder of radius `r` and height `h` standing on the XY plane, as analytic records.
+fn cylinder(r: f64, h: f64) -> Brep {
+ turned(r, r, h)
+}
+
+/// A cylinder (`r0 == r1`) or a cone frustum from radius `r0` at z = 0 to `r1` at z = `h`,
+/// its seam at angle 0.
+fn turned(r0: f64, r1: f64, h: f64) -> Brep {
+ let tau = std::f64::consts::TAU;
+ let seam = Edge { vertices: [0, 1], curve: Curve::Line { start: [r0, 0., 0.], end: [r1, 0., h] } };
+ let edges = vec![circle([0.; 3], r0, 0), circle([0., 0., h], r1, 1), seam];
+ let side = if r0 == r1 {
+ Surface::Cylinder { frame: frame_at([0.; 3]), radius: r0, angle: [0., tau], height: [0., h] }
+ } else {
+ Surface::Cone { frame: frame_at([0.; 3]), radius_at_origin: r0, half_angle: ((r1 - r0) / h).atan(), angle: [0., tau], height: [0., h] }
+ };
+ let faces = vec![
+ Face { loops: vec![vec![uses(0, true), uses(2, true), uses(1, false), uses(2, false)]], surface: side, forward: true },
+ Face {
+ loops: vec![vec![uses(0, false)]],
+ surface: Surface::Plane { origin: [0.; 3], u_axis: [1., 0., 0.], v_axis: [0., -1., 0.] },
+ forward: true,
+ },
+ Face {
+ loops: vec![vec![uses(1, true)]],
+ surface: Surface::Plane { origin: [0., 0., h], u_axis: [1., 0., 0.], v_axis: [0., 1., 0.] },
+ forward: true,
+ },
+ ];
+ Brep { version: crate::brep::VERSION, shells: vec![Shell { vertices: vec![[r0, 0., 0.], [r1, 0., h]], edges, faces }] }
+}
+
+/// A sphere of radius `r` at the origin: two hemispheres meeting at the equator.
+fn sphere(r: f64) -> Brep {
+ let (tau, half) = (std::f64::consts::TAU, std::f64::consts::FRAC_PI_2);
+ let hemisphere = |latitude: [f64; 2], forward| Face {
+ loops: vec![vec![uses(0, forward)]],
+ surface: Surface::Sphere { frame: frame_at([0.; 3]), radius: r, longitude: [0., tau], latitude },
+ forward: true,
+ };
+ let faces = vec![hemisphere([0., half], true), hemisphere([-half, 0.], false)];
+ Brep { version: crate::brep::VERSION, shells: vec![Shell { vertices: vec![[r, 0., 0.]], edges: vec![circle([0.; 3], r, 0)], faces }] }
+}
+
+/// A torus about Z (major radius `big`, minor `small`): top and bottom halves meeting at the
+/// outer and inner equators.
+fn torus(big: f64, small: f64) -> Brep {
+ let (tau, pi) = (std::f64::consts::TAU, std::f64::consts::PI);
+ let half = |meridian: [f64; 2], forward: bool| Face {
+ loops: vec![vec![uses(0, forward)], vec![uses(1, !forward)]],
+ surface: Surface::Torus { frame: frame_at([0.; 3]), major_radius: big, minor_radius: small, longitude: [0., tau], meridian },
+ forward: true,
+ };
+ let edges = vec![circle([0.; 3], big + small, 0), circle([0.; 3], big - small, 1)];
+ let faces = vec![half([0., pi], true), half([pi, tau], false)];
+ Brep { version: crate::brep::VERSION, shells: vec![Shell { vertices: vec![[big + small, 0., 0.], [big - small, 0., 0.]], edges, faces }] }
+}
+
+/// A bilinear (twisted) spline patch over x, y in [-5, 5] with z between 0 and 1.
+fn twisted_patch() -> Brep {
+ let p = [[-5., -5., 0.], [5., -5., 1.], [5., 5., 0.], [-5., 5., 1.]];
+ let edges =
+ (0..4).map(|i| Edge { vertices: [i as u32, ((i + 1) % 4) as u32], curve: Curve::Line { start: p[i], end: p[(i + 1) % 4] } }).collect();
+ let face = Face {
+ loops: vec![(0..4).map(|e| uses(e, true)).collect()],
+ surface: Surface::Spline { u_knots: vec![0., 0., 1., 1.], v_knots: vec![0., 0., 1., 1.], points: vec![vec![p[0], p[3]], vec![p[1], p[2]]] },
+ forward: true,
+ };
+ Brep { version: crate::brep::VERSION, shells: vec![Shell { vertices: p.to_vec(), edges, faces: vec![face] }] }
+}
+
+fn pieces(d: &Drawing) -> impl Iterator<Item = &Piece> {
+ d.lines.iter().flat_map(|l| l.pieces.iter())
+}
+
+/// The turn of a circle edge's pieces drawn as exact conic arcs, or `None` when they are all
+/// drawn as chords (weights too far apart to certify the circle): never a wrong exact arc.
+fn turn_or_chords<'a>(pieces: impl Iterator<Item = &'a Piece>) -> Option<f64> {
+ let pieces: Vec<&Piece> = pieces.collect();
+ if pieces.iter().all(|p| matches!(p.accuracy, CurveAccuracy::Sampled { .. })) {
+ return None;
+ }
+ let mut sweep = 0.;
+ for p in pieces {
+ assert_eq!(p.accuracy, CurveAccuracy::Analytic, "{p:?}");
+ for g in &p.geometry {
+ let Seg2::Conic { w, .. } = *g else { panic!("a circle is drawn as conic arcs: {g:?}") };
+ sweep += 2. * w.acos();
+ }
+ }
+ Some(sweep)
+}
+
+fn silhouette_pieces(d: &Drawing) -> Vec<&Piece> {
+ d.lines.iter().filter(|l| matches!(l.source, Source::Silhouette { .. })).flat_map(|l| l.pieces.iter()).collect()
+}
+
+fn edge_line(d: &Drawing, placement: usize, edge: usize) -> &Line {
+ let found = d.lines.iter().find(|l| l.placement == placement && matches!(l.source, Source::Edge { edge: e, .. } if e == edge));
+ found.unwrap_or_else(|| panic!("no line for edge {edge} of placement {placement}"))
+}
+
+#[test]
+fn a_cylinder_seen_from_the_side_has_exact_silhouette_lines() {
+ let def = prepare(&cylinder(10., 30.), &Options::default()).unwrap();
+ // Slightly from above, along +X (rulings at +-90 degrees) and along +Y (rulings at 0 and
+ // 180 degrees: one runs along the seam, which is not drawn as an edge).
+ for dir in [Vec3::new(1., 0., -0.3), Vec3::new(0., 1., -0.3)] {
+ let view = View::new(dir, Vec3::new(0., 0., 1.)).unwrap();
+ let d = hidden_lines(std::slice::from_ref(&def), &[identity(0, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ check_cylinder_sides(&d, &view);
+ }
+}
+
+fn check_cylinder_sides(d: &Drawing, view: &View) {
+ let sil = silhouette_pieces(d);
+ assert!(!sil.is_empty());
+ let rise = 30. * view.y.z;
+ let mut sides = Vec::new();
+ for p in sil {
+ assert_eq!(p.accuracy, CurveAccuracy::Analytic);
+ assert_eq!(p.visibility, Visibility::Visible);
+ for g in &p.geometry {
+ let Seg2::Line { a, b } = *g else { panic!("a silhouette ruling is a line: {g:?}") };
+ assert!((a.x.abs() - 10.).abs() < 1e-12 && (a.x - b.x).abs() < 1e-12, "{g:?}");
+ sides.push((a.x.signum(), (b.y - a.y).abs()));
+ }
+ }
+ for side in [-1., 1.] {
+ let len: f64 = sides.iter().filter(|s| s.0 == side).map(|s| s.1).sum();
+ assert!((len - rise).abs() < 1e-9, "side {side}: {len} vs {rise}");
+ }
+ assert_eq!(d.stats.uncertain_uncovered, 0, "{:?}", d.stats);
+ assert!(d.unsupported.is_empty());
+}
+
+#[test]
+fn a_sphere_outline_is_exact_conic_arcs_in_any_view() {
+ let def = prepare(&sphere(10.), &Options::default()).unwrap();
+ let views = [
+ (Vec3::new(1., 2., 3.), Vec3::new(0., 0., 1.)),
+ (Vec3::new(0., 0., -1.), Vec3::new(0., 1., 0.)),
+ (Vec3::new(-0.3, 1., 0.1), Vec3::new(0., 0., 1.)),
+ ];
+ for (dir, up) in views {
+ let view = View::new(dir, up).unwrap();
+ let d = hidden_lines(std::slice::from_ref(&def), &[identity(0, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ // The outline: every uncovered visible piece lies on the circle of radius 10.
+ let mut drawn = 0.;
+ for p in
+ pieces(&d).filter(|p| p.visibility == Visibility::Visible && !p.covered && p.geometry.iter().all(|g| matches!(g, Seg2::Conic { .. })))
+ {
+ assert_eq!(p.accuracy, CurveAccuracy::Analytic);
+ for g in &p.geometry {
+ let ends = (g.point_at(0.), g.point_at(1.));
+ if (ends.0.len() - 10.).abs() > 1e-9 {
+ continue;
+ }
+ for k in 0..=16 {
+ let q = g.point_at(k as f64 / 16.);
+ assert!((q.len() - 10.).abs() < 1e-9, "{dir:?}: {q:?} off the outline");
+ }
+ drawn += ends.0.dist(ends.1);
+ }
+ }
+ assert!(drawn > 40., "{dir:?}: the outline is drawn ({drawn} mm of chords)");
+ for p in silhouette_pieces(&d) {
+ assert!(p.geometry.iter().all(|g| matches!(g, Seg2::Conic { .. })), "{dir:?}: {p:?}");
+ }
+ assert_eq!(d.stats.uncertain_uncovered, 0, "{dir:?}: {:?}", d.stats);
+ }
+}
+
+#[test]
+fn a_torus_seen_face_on_is_drawn_at_both_equators() {
+ let def = prepare(&torus(20., 5.), &Options::default()).unwrap();
+ let view = View::new(Vec3::new(0., 0., -1.), Vec3::new(0., 1., 0.)).unwrap();
+ let d = hidden_lines(&[def], &[identity(0, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ let (mut outer, mut inner) = (false, false);
+ for p in pieces(&d).filter(|p| p.visibility == Visibility::Visible && !p.covered) {
+ for g in &p.geometry {
+ for k in 0..=8 {
+ let r = g.point_at(k as f64 / 8.).len();
+ assert!((r - 25.).abs() < 1e-9 || (r - 15.).abs() < 1e-9, "a point at radius {r}");
+ outer |= (r - 25.).abs() < 1e-9;
+ inner |= (r - 15.).abs() < 1e-9;
+ }
+ }
+ }
+ assert!(outer && inner);
+ // Both equators are silhouettes along the seams between the halves: one curve each.
+ assert_eq!(d.stats.silhouettes, 2, "{:?}", d.stats);
+ assert_eq!(d.stats.uncertain_uncovered, 0, "{:?}", d.stats);
+}
+
+#[test]
+fn an_edge_under_a_torus_is_hidden_where_the_tube_covers_it() {
+ // Looking down on a torus (R 20, r 5) over a long bar: the bar's top edge along y = 1 is
+ // hidden where sqrt(x^2 + 1) is between 15 and 25.
+ let t = prepare(&torus(20., 5.), &Options::default()).unwrap();
+ let bar = prepare(&cuboid([-40., -1., -12.], [40., 1., -10.]), &Options::default()).unwrap();
+ let view = View::new(Vec3::new(0., 0., -1.), Vec3::new(0., 1., 0.)).unwrap();
+ let d = hidden_lines(&[t, bar], &[identity(0, [0.; 3]), identity(1, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ // Edge 3 joins corners 6 (-40, 1, -10) and 7 (40, 1, -10): x = 80 t - 40.
+ let hidden: Vec<[f64; 2]> =
+ edge_line(&d, 1, 3).pieces.iter().filter(|p| p.visibility == Visibility::Hidden).map(|p| [p.t[0] * 80. - 40., p.t[1] * 80. - 40.]).collect();
+ let (a, b) = (224f64.sqrt(), 624f64.sqrt());
+ assert_eq!(hidden.len(), 2, "{hidden:?}");
+ for (h, want) in hidden.iter().zip([[-b, -a], [a, b]]) {
+ assert!((h[0] - want[0]).abs() < 1e-9 && (h[1] - want[1]).abs() < 1e-9, "{hidden:?}");
+ }
+ assert_eq!(d.stats.uncertain_uncovered, 0, "{:?}", d.stats);
+}
+
+#[test]
+fn a_part_far_from_the_origin_draws_the_same_as_at_the_origin() {
+ let def = prepare(&cylinder(10., 30.), &Options::default()).unwrap();
+ let view = View::new(Vec3::new(-1., -0.7, -0.4), Vec3::new(0., 0., 1.)).unwrap();
+ let defs = [def];
+ let states = |d: &Drawing| -> Vec<(Visibility, bool, usize)> { pieces(d).map(|p| (p.visibility, p.covered, p.geometry.len())).collect() };
+ let base = hidden_lines(&defs, &[identity(0, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ for t in [[1e5, 2e5, -3e5], [1e7, 2e7, -3e7]] {
+ let d = hidden_lines(&defs, &[identity(0, t)], &view, &Options::default(), &never).unwrap();
+ assert_eq!(states(&base), states(&d), "classification moved at {t:?}");
+ let shift = view.screen(Vec3::new(t[0], t[1], t[2]));
+ // Only the final shift back to the caller's frame rounds: about 1e-16 of |t|.
+ let tol = 1e-15 * (t[0].abs() + t[1].abs() + t[2].abs()) + 1e-9;
+ for (a, b) in pieces(&base).zip(pieces(&d)) {
+ for (g, h) in a.geometry.iter().zip(&b.geometry) {
+ for s in [0., 0.5, 1.] {
+ let (p, q) = (g.point_at(s), h.point_at(s));
+ assert!((q.x - shift[0] - p.x).abs() < tol && (q.y - shift[1] - p.y).abs() < tol, "{p:?} vs {q:?} at {t:?}");
+ }
+ }
+ }
+ }
+}
+
+#[test]
+fn freeform_faces_are_reported_and_never_hide_for_certain() {
+ let patch = prepare(&twisted_patch(), &Options::default()).unwrap();
+ assert_eq!(patch.report.freeform_faces, vec![0]);
+ // A bar under the patch, seen from above: its top edges (2, 3, 6, 7) are behind the patch only.
+ let bar = prepare(&cuboid([-2., -1., -5.], [2., 1., -3.]), &Options::default()).unwrap();
+ let view = View::new(Vec3::new(0.1, 0.05, -1.), Vec3::new(0., 1., 0.)).unwrap();
+ let defs = [patch, bar];
+ let scene = [identity(0, [0.; 3]), identity(1, [0.; 3])];
+ let top = |d: &Drawing| -> Vec<Visibility> {
+ [2, 3, 6, 7].iter().flat_map(|&e| edge_line(d, 1, e).pieces.iter().map(|p| p.visibility)).collect::<Vec<_>>()
+ };
+ let d = hidden_lines(&defs, &scene, &view, &Options::default(), &never).unwrap();
+ assert_eq!(d.unsupported, vec![Unsupported { placement: 0, face: 0, reason: "freeform face" }]);
+ assert!(top(&d).iter().all(|v| *v == Visibility::Uncertain), "{:?}", top(&d));
+ // With freeform faces handled the patch hides them.
+ let d = hidden_lines(&defs, &scene, &view, &Options { freeform: true, ..Options::default() }, &never).unwrap();
+ assert!(d.unsupported.is_empty());
+ assert!(top(&d).iter().all(|v| *v == Visibility::Hidden), "{:?}", top(&d));
+}
+
+#[test]
+fn a_flat_spline_patch_is_a_plane_that_hides_for_certain() {
+ // A bilinear patch with all four corners at z = 0 over a bar whose top is at z = -1.
+ let p = [[-5., -5., 0.], [5., -5., 0.], [5., 5., 0.], [-5., 5., 0.]];
+ let edges =
+ (0..4).map(|i| Edge { vertices: [i as u32, ((i + 1) % 4) as u32], curve: Curve::Line { start: p[i], end: p[(i + 1) % 4] } }).collect();
+ let face = Face {
+ loops: vec![(0..4).map(|e| uses(e, true)).collect()],
+ surface: Surface::Spline { u_knots: vec![0., 0., 1., 1.], v_knots: vec![0., 0., 1., 1.], points: vec![vec![p[0], p[3]], vec![p[1], p[2]]] },
+ forward: true,
+ };
+ let patch =
+ prepare(&Brep { version: crate::brep::VERSION, shells: vec![Shell { vertices: p.to_vec(), edges, faces: vec![face] }] }, &Options::default())
+ .unwrap();
+ assert!(patch.report.freeform_faces.is_empty());
+ let bar = prepare(&cuboid([-2., -1., -3.], [2., 1., -1.]), &Options::default()).unwrap();
+ let view = View::new(Vec3::new(0.1, 0.05, -1.), Vec3::new(0., 1., 0.)).unwrap();
+ let d = hidden_lines(&[patch, bar], &[identity(0, [0.; 3]), identity(1, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ assert!(d.unsupported.is_empty());
+ let top: Vec<Visibility> = [2, 3, 6, 7].iter().flat_map(|&e| edge_line(&d, 1, e).pieces.iter().map(|p| p.visibility)).collect();
+ assert!(top.iter().all(|v| *v == Visibility::Hidden), "{top:?}");
+}
+
+/// The Bernstein coefficients of the product of two polynomials given by theirs.
+fn bernstein_product(a: &[f64], b: &[f64]) -> Vec<f64> {
+ let binom = |n: usize, k: usize| (0..k).fold(1f64, |acc, i| acc * (n - i) as f64 / (i + 1) as f64);
+ let (m, n) = (a.len() - 1, b.len() - 1);
+ (0..=m + n)
+ .map(|k| {
+ let terms = (k.saturating_sub(n)..=k.min(m)).map(|i| binom(m, i) * binom(n, k - i) * a[i] * b[k - i]);
+ terms.sum::<f64>() / binom(m + n, k)
+ })
+ .collect()
+}
+
+#[test]
+fn a_circle_racing_through_its_first_turn_is_drawn_whole_edge_on() {
+ // A closed rational sextic on the circle of radius 10: 10 (A + iB)^6 / |A + iB|^6 with
+ // A = 0.05 + 0.95 t, B = sqrt 3 t. It turns 3.6 rad in its first screen sample step, and
+ // seen along its plane that step looks straight; the arcs must still turn 360 degrees.
+ // A + iB = 0.05 (1 - t) + (1 + i sqrt 3) t, so (A + iB)^6 has the Bernstein coefficients
+ // 0.05^(6-k) (1 + i sqrt 3)^k, and A^2 + B^2 the coefficients 0.0025, 0.05, 4.
+ let c1 = (1f64, 3f64.sqrt());
+ let mut num = Vec::new();
+ let mut pw = (1f64, 0f64);
+ for k in 0..=6 {
+ num.push((0.05f64.powi(6 - k) * pw.0, 0.05f64.powi(6 - k) * pw.1));
+ pw = (pw.0 * c1.0 - pw.1 * c1.1, pw.0 * c1.1 + pw.1 * c1.0);
+ }
+ let q = [0.0025, 0.05, 4.];
+ let w = bernstein_product(&bernstein_product(&q, &q), &q);
+ let homogeneous: Vec<[f64; 4]> = num.iter().zip(&w).map(|((re, im), w)| [10. * re, 10. * im, 0., *w]).collect();
+ let start = [10., 0., 0.];
+ let disc = Brep {
+ version: crate::brep::VERSION,
+ shells: vec![Shell {
+ vertices: vec![start],
+ edges: vec![Edge { vertices: [0, 0], curve: Curve::RationalSpline { knots: [[0.; 7], [1.; 7]].concat(), homogeneous } }],
+ faces: vec![Face {
+ loops: vec![vec![uses(0, true)]],
+ surface: Surface::Plane { origin: [0.; 3], u_axis: [1., 0., 0.], v_axis: [0., 1., 0.] },
+ forward: true,
+ }],
+ }],
+ };
+ let def = prepare(&disc, &Options::default()).unwrap();
+ let view = View::new(Vec3::new(0., 1., 0.), Vec3::new(0., 0., 1.)).unwrap();
+ let d = hidden_lines(&[def], &[identity(0, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ if let Some(sweep) = turn_or_chords(pieces(&d)) {
+ assert!((sweep - std::f64::consts::TAU).abs() < 1e-9, "the arcs turn {sweep} rad");
+ }
+}
+
+#[test]
+fn an_arc_racing_through_almost_a_full_turn_is_drawn_whole() {
+ // 10 z^4 / |z|^4 with z = (1 - t) + 400 e^(i (pi/2 - 0.01)) t: an exact arc of radius 10 that
+ // turns 2 pi - 0.04 almost all within t < 0.01, closed by a short line. Seen along its plane
+ // at -0.45 rad, the first samples look straight and turn little between them; the arcs
+ // must still turn the whole 2 pi - 0.04.
+ let phi = std::f64::consts::FRAC_PI_2 - 0.01;
+ let c1 = (400. * phi.cos(), 400. * phi.sin());
+ let mut num = Vec::new();
+ let mut pw = (1f64, 0f64);
+ for _ in 0..=4 {
+ num.push(pw);
+ pw = (pw.0 * c1.0 - pw.1 * c1.1, pw.0 * c1.1 + pw.1 * c1.0);
+ }
+ let q = [1., c1.0, 160_000.];
+ let w = bernstein_product(&q, &q);
+ let homogeneous: Vec<[f64; 4]> = num.iter().zip(&w).map(|((re, im), w)| [10. * re, 10. * im, 0., *w]).collect();
+ let sweep_want = 4. * phi;
+ let end = [10. * sweep_want.cos(), 10. * sweep_want.sin(), 0.];
+ let shape = Brep {
+ version: crate::brep::VERSION,
+ shells: vec![Shell {
+ vertices: vec![[10., 0., 0.], end],
+ edges: vec![
+ Edge { vertices: [0, 1], curve: Curve::RationalSpline { knots: [[0.; 5], [1.; 5]].concat(), homogeneous } },
+ Edge { vertices: [1, 0], curve: Curve::Line { start: end, end: [10., 0., 0.] } },
+ ],
+ faces: vec![Face {
+ loops: vec![vec![uses(0, true), uses(1, true)]],
+ surface: Surface::Plane { origin: [0.; 3], u_axis: [1., 0., 0.], v_axis: [0., 1., 0.] },
+ forward: true,
+ }],
+ }],
+ };
+ let def = prepare(&shape, &Options::default()).unwrap();
+ let view = View::new(Vec3::new(0.45f64.sin(), 0.45f64.cos(), 0.), Vec3::new(0., 0., 1.)).unwrap();
+ let d = hidden_lines(&[def], &[identity(0, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ if let Some(sweep) = turn_or_chords(edge_line(&d, 0, 0).pieces.iter()) {
+ assert!((sweep - sweep_want).abs() < 1e-9, "the arcs turn {sweep} rad, want {sweep_want}");
+ }
+}
+
+#[test]
+fn a_short_piece_of_a_fast_arc_turns_its_own_way() {
+ // An exact arc of radius 10 as a quartic rational spline of two spans: 0 to 5 rad over the
+ // parameters 0 to 1e-6, then on to 5.8 rad; a chord closes the loop. A box in front, seen
+ // along -Z, cuts the arc into pieces a fraction of 1e-6 long that turn several radians.
+ let span = |c0: (f64, f64), c1: (f64, f64)| -> Vec<[f64; 4]> {
+ let mul = |a: (f64, f64), b: (f64, f64)| (a.0 * b.0 - a.1 * b.1, a.0 * b.1 + a.1 * b.0);
+ let pw = |c: (f64, f64), k: usize| (0..k).fold((1., 0.), |acc, _| mul(acc, c));
+ let q = [c0.0 * c0.0 + c0.1 * c0.1, c0.0 * c1.0 + c0.1 * c1.1, c1.0 * c1.0 + c1.1 * c1.1];
+ let w = bernstein_product(&q, &q);
+ (0..=4)
+ .map(|k| {
+ let z = mul(pw(c0, 4 - k), pw(c1, k));
+ [10. * z.0, 10. * z.1, 0., w[k]]
+ })
+ .collect()
+ };
+ let unit = |a: f64| (a.cos(), a.sin());
+ // Weights far apart in the first span (|z| from 1 to 40) crowd its turn near its start.
+ let fast = (40. * 1.25f64.cos(), 40. * 1.25f64.sin());
+ let first = span(unit(0.), fast);
+ let second = span(fast, unit(1.45));
+ let homogeneous: Vec<[f64; 4]> = first.iter().chain(second.iter().skip(1)).copied().collect();
+ let end = [10. * 5.8f64.cos(), 10. * 5.8f64.sin(), 0.];
+ let shape = Brep {
+ version: crate::brep::VERSION,
+ shells: vec![Shell {
+ vertices: vec![[10., 0., 0.], end],
+ edges: vec![
+ Edge { vertices: [0, 1], curve: Curve::RationalSpline { knots: [vec![0.; 5], vec![1e-6; 4], vec![1.; 5]].concat(), homogeneous } },
+ Edge { vertices: [1, 0], curve: Curve::Line { start: end, end: [10., 0., 0.] } },
+ ],
+ faces: vec![Face {
+ loops: vec![vec![uses(0, true), uses(1, true)]],
+ surface: Surface::Plane { origin: [0.; 3], u_axis: [1., 0., 0.], v_axis: [0., 1., 0.] },
+ forward: true,
+ }],
+ }],
+ };
+ let arc = prepare(&shape, &Options::default()).unwrap();
+ let block = prepare(&cuboid([-8.2, -11., 1.], [11., -0.001, 2.]), &Options::default()).unwrap();
+ let view = View::new(Vec3::new(0., 0., -1.), Vec3::new(0., 1., 0.)).unwrap();
+ let d = hidden_lines(&[arc, block], &[identity(0, [0.; 3]), identity(1, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ let line = edge_line(&d, 0, 0);
+ assert!(line.pieces.len() > 1, "the block splits the arc");
+ if let Some(sweep) = turn_or_chords(line.pieces.iter()) {
+ assert!((sweep - 5.8).abs() < 1e-9, "the pieces turn {sweep} rad in all, want 5.8");
+ }
+}
+
+/// The homogeneous control points of an exact quartic arc of radius 10 about the origin from
+/// angle `a0` to `a1` (z^4 / |z|^4 with z running straight between the quarter angles).
+fn quartic_arc(a0: f64, a1: f64) -> Vec<[f64; 4]> {
+ let (c0, c1) = ((a0 / 4.).cos(), (a0 / 4.).sin());
+ let (d0, d1) = ((a1 / 4.).cos(), (a1 / 4.).sin());
+ let mul = |a: (f64, f64), b: (f64, f64)| (a.0 * b.0 - a.1 * b.1, a.0 * b.1 + a.1 * b.0);
+ let pw = |c: (f64, f64), k: usize| (0..k).fold((1., 0.), |acc, _| mul(acc, c));
+ let q = [1., c0 * d0 + c1 * d1, 1.];
+ let w = bernstein_product(&q, &q);
+ (0..=4)
+ .map(|k| {
+ let z = mul(pw((c0, c1), 4 - k), pw((d0, d1), k));
+ [10. * z.0, 10. * z.1, 0., w[k]]
+ })
+ .collect()
+}
+
+#[test]
+fn an_arc_whose_whole_domain_is_8_roundings_wide_is_not_guessed() {
+ // An exact arc of radius 10 turning +3.75 rad over the parameters 0.25 to 0.25 + 2^-51
+ // (8 roundings), closed by a chord: drawn as the right arc or as chords, never as the short
+ // arc the other way round, through (0, -10).
+ let k = 0.25 + 2f64.powi(-51);
+ let end = [10. * 3.75f64.cos(), 10. * 3.75f64.sin(), 0.];
+ let shape = Brep {
+ version: crate::brep::VERSION,
+ shells: vec![Shell {
+ vertices: vec![[10., 0., 0.], end],
+ edges: vec![
+ Edge {
+ vertices: [0, 1],
+ curve: Curve::RationalSpline { knots: [vec![0.25; 5], vec![k; 5]].concat(), homogeneous: quartic_arc(0., 3.75) },
+ },
+ Edge { vertices: [1, 0], curve: Curve::Line { start: end, end: [10., 0., 0.] } },
+ ],
+ faces: vec![Face {
+ loops: vec![vec![uses(0, true), uses(1, true)]],
+ surface: Surface::Plane { origin: [0.; 3], u_axis: [1., 0., 0.], v_axis: [0., 1., 0.] },
+ forward: true,
+ }],
+ }],
+ };
+ let def = prepare(&shape, &Options::default()).unwrap();
+ let view = View::new(Vec3::new(0., 0., -1.), Vec3::new(0., 1., 0.)).unwrap();
+ let d = hidden_lines(&[def], &[identity(0, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ if let Some(sweep) = turn_or_chords(edge_line(&d, 0, 0).pieces.iter()) {
+ assert!((sweep - 3.75).abs() < 1e-9, "the arcs turn {sweep} rad");
+ }
+ for p in &edge_line(&d, 0, 0).pieces {
+ for g in &p.geometry {
+ for s in [0., 0.25, 0.5, 0.75, 1.] {
+ assert!(g.point_at(s).dist(Vec2::new(0., -10.)) > 1., "{g:?} passes the wrong side");
+ }
+ }
+ }
+}
+
+#[test]
+fn a_piece_in_a_knot_span_of_1e_11_turns_its_own_way() {
+ // An exact arc of radius 10 in three quartic spans: 0 to 0.1 rad, then 0.1 to 3.85 rad over
+ // the parameters 0.25 to 0.25 + 1e-11, then on to 4.5 rad. Two blocks in front hide the
+ // outer spans, so the middle one is a visible piece of its own turning 3.75 rad.
+ let span = quartic_arc;
+ let (s1, s2, s3) = (span(0., 0.1), span(0.1, 3.85), span(3.85, 4.5));
+ let homogeneous: Vec<[f64; 4]> = s1.iter().chain(s2.iter().skip(1)).chain(s3.iter().skip(1)).copied().collect();
+ let k = 0.25 + 1e-11;
+ let end = [10. * 4.5f64.cos(), 10. * 4.5f64.sin(), 0.];
+ let shape = Brep {
+ version: crate::brep::VERSION,
+ shells: vec![Shell {
+ vertices: vec![[10., 0., 0.], end],
+ edges: vec![
+ Edge {
+ vertices: [0, 1],
+ curve: Curve::RationalSpline { knots: [vec![0.; 5], vec![0.25; 4], vec![k; 4], vec![1.; 5]].concat(), homogeneous },
+ },
+ Edge { vertices: [1, 0], curve: Curve::Line { start: end, end: [10., 0., 0.] } },
+ ],
+ faces: vec![Face {
+ loops: vec![vec![uses(0, true), uses(1, true)]],
+ surface: Surface::Plane { origin: [0.; 3], u_axis: [1., 0., 0.], v_axis: [0., 1., 0.] },
+ forward: true,
+ }],
+ }],
+ };
+ let arc = prepare(&shape, &Options::default()).unwrap();
+ let low = prepare(&cuboid([9., -1., 1.], [11., 10. * 0.1f64.sin(), 2.]), &Options::default()).unwrap();
+ let high = prepare(&cuboid([-11., -11., 1.], [0., 10. * 3.85f64.sin(), 2.]), &Options::default()).unwrap();
+ let view = View::new(Vec3::new(0., 0., -1.), Vec3::new(0., 1., 0.)).unwrap();
+ let scene = [identity(0, [0.; 3]), identity(1, [0.; 3]), identity(2, [0.; 3])];
+ let d = hidden_lines(&[arc, low, high], &scene, &view, &Options::default(), &never).unwrap();
+ let line = edge_line(&d, 0, 0);
+ let mut sweep = 0.;
+ for p in &line.pieces {
+ for g in &p.geometry {
+ match *g {
+ Seg2::Conic { w, .. } => sweep += 2. * w.acos(),
+ _ => panic!("an arc is drawn as conic arcs: {g:?}"),
+ }
+ }
+ }
+ assert!(line.pieces.len() >= 3, "{:?}", line.pieces.iter().map(|p| p.t).collect::<Vec<_>>());
+ assert!((sweep - 4.5).abs() < 1e-9, "the pieces turn {sweep} rad in all, want 4.5");
+}
+
+#[test]
+fn a_curve_that_swerves_where_its_weight_is_near_zero_is_not_taken_for_a_circle() {
+ // 1e-12 (1 - t)^3 (0, -10) + t Q(t), Q the exact quarter circle of radius 10 from (10, 0)
+ // to (0, 10): on the circle at every check point to 1.3e-9 mm, yet near t = 1e-12, where
+ // its weight is tiny, it passes (5, -5), 2.9 mm inside. Drawn as chords, not an arc.
+ let s = std::f64::consts::FRAC_1_SQRT_2;
+ let q = [[10., 0., 0., 1.], [10. * s, 10. * s, 0., s], [0., 10., 0., 1.]];
+ let homogeneous: Vec<[f64; 4]> = (0..4)
+ .map(|k| {
+ let tq: Vec<f64> = (0..4).map(|c| bernstein_product(&[0., 1.], &q.map(|h| h[c]))[k]).collect();
+ let a = if k == 0 { [0., -10e-12, 0., 1e-12] } else { [0.; 4] };
+ [tq[0] + a[0], tq[1] + a[1], tq[2] + a[2], tq[3] + a[3]]
+ })
+ .collect();
+ let shape = Brep {
+ version: crate::brep::VERSION,
+ shells: vec![Shell {
+ vertices: vec![[0., -10., 0.], [0., 10., 0.]],
+ edges: vec![
+ Edge { vertices: [0, 1], curve: Curve::RationalSpline { knots: [[0.; 4], [1.; 4]].concat(), homogeneous } },
+ Edge { vertices: [1, 0], curve: Curve::Line { start: [0., 10., 0.], end: [0., -10., 0.] } },
+ ],
+ faces: vec![Face {
+ loops: vec![vec![uses(0, true), uses(1, true)]],
+ surface: Surface::Plane { origin: [0.; 3], u_axis: [1., 0., 0.], v_axis: [0., 1., 0.] },
+ forward: true,
+ }],
+ }],
+ };
+ let def = prepare(&shape, &Options::default()).unwrap();
+ let view = View::new(Vec3::new(0., 0., -1.), Vec3::new(0., 1., 0.)).unwrap();
+ let d = hidden_lines(&[def], &[identity(0, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ assert!(edge_line(&d, 0, 0).pieces.iter().all(|p| matches!(p.accuracy, CurveAccuracy::Sampled { .. })), "{d:?}");
+}
+
+#[test]
+fn an_edge_leaving_a_left_out_faces_box_in_front_stays_visible() {
+ // Over the twisted patch (x, y in [-5, 5], z in [0, 1]), seen from above, an edge from
+ // (-10, 0, -1) up to (0, 0, 5): below the patch's level only outside its box, inside the
+ // box above the patch. Nothing can hide it.
+ let patch = prepare(&twisted_patch(), &Options::default()).unwrap();
+ let c = [[-10., 0., -1.], [0., 0., 5.], [0., 0.2, 5.], [-10., 0.2, -1.]];
+ let edges =
+ (0..4).map(|i| Edge { vertices: [i as u32, ((i + 1) % 4) as u32], curve: Curve::Line { start: c[i], end: c[(i + 1) % 4] } }).collect();
+ let face = Face {
+ loops: vec![(0..4).map(|e| uses(e, true)).collect()],
+ surface: Surface::Plane { origin: c[0], u_axis: [10., 0., 6.], v_axis: [0., 0.2, 0.] },
+ forward: true,
+ };
+ let strip =
+ prepare(&Brep { version: crate::brep::VERSION, shells: vec![Shell { vertices: c.to_vec(), edges, faces: vec![face] }] }, &Options::default())
+ .unwrap();
+ let view = View::new(Vec3::new(0., 0., -1.), Vec3::new(0., 1., 0.)).unwrap();
+ let d = hidden_lines(&[patch, strip], &[identity(0, [0.; 3]), identity(1, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ let states: Vec<([f64; 2], Visibility)> = edge_line(&d, 1, 0).pieces.iter().map(|p| (p.t, p.visibility)).collect();
+ assert!(states.iter().all(|(_, v)| *v == Visibility::Visible), "{states:?}");
+}
+
+#[test]
+fn a_nearly_straight_cubic_is_not_taken_for_a_huge_circle() {
+ // x = 1000 t, y = 0.071 t - 0.113 t^2 + 0.042 t^3: within 0.002 mm of a circle of radius
+ // about 1e7, which is 2e-10 of that radius but 2e-6 of the curve. Drawn as chords.
+ let pts = [[0., 0., 0.], [1000. / 3., 0.071 / 3., 0.], [2000. / 3., 0.071 * 2. / 3. - 0.113 / 3., 0.], [1000., 0., 0.]];
+ let shape = Brep {
+ version: crate::brep::VERSION,
+ shells: vec![Shell {
+ vertices: vec![[0.; 3], [1000., 0., 0.]],
+ edges: vec![
+ Edge { vertices: [0, 1], curve: Curve::Spline { knots: [[0.; 4], [1.; 4]].concat(), points: pts.to_vec() } },
+ Edge { vertices: [1, 0], curve: Curve::Line { start: [1000., 0., 0.], end: [0.; 3] } },
+ ],
+ faces: vec![Face {
+ loops: vec![vec![uses(0, true), uses(1, true)]],
+ surface: Surface::Plane { origin: [0.; 3], u_axis: [1., 0., 0.], v_axis: [0., 1., 0.] },
+ forward: true,
+ }],
+ }],
+ };
+ let def = prepare(&shape, &Options::default()).unwrap();
+ let view = View::new(Vec3::new(0., 0., -1.), Vec3::new(0., 1., 0.)).unwrap();
+ let d = hidden_lines(&[def], &[identity(0, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ assert!(edge_line(&d, 0, 0).pieces.iter().all(|p| matches!(p.accuracy, CurveAccuracy::Sampled { .. })), "{d:?}");
+}
+
+#[test]
+fn an_edge_dipping_behind_a_left_out_face_between_samples_is_uncertain() {
+ // Under a freeform patch over x in [0, 10], y in [0, 1] (z within 1e-4 of zero, zero along
+ // y = 0.5), a quadratic edge x = 10 t, y = 0.5, z = 20 (t - 0.0075)(t - 0.02375) dips
+ // below the patch for t from 0.0075 to 0.02375, between its samples; its projection is
+ // straight, so the screen never asks for more.
+ let e = 1e-4;
+ let p = [[0., 0., e], [10., 0., -e], [10., 1., e], [0., 1., -e]];
+ let edges =
+ (0..4).map(|i| Edge { vertices: [i as u32, ((i + 1) % 4) as u32], curve: Curve::Line { start: p[i], end: p[(i + 1) % 4] } }).collect();
+ let face = Face {
+ loops: vec![(0..4).map(|e| uses(e, true)).collect()],
+ surface: Surface::Spline { u_knots: vec![0., 0., 1., 1.], v_knots: vec![0., 0., 1., 1.], points: vec![vec![p[0], p[3]], vec![p[1], p[2]]] },
+ forward: true,
+ };
+ let patch =
+ prepare(&Brep { version: crate::brep::VERSION, shells: vec![Shell { vertices: p.to_vec(), edges, faces: vec![face] }] }, &Options::default())
+ .unwrap();
+ assert_eq!(patch.report.freeform_faces, vec![0]);
+ // z = 20 t^2 - 0.625 t + 0.0035625 as a quadratic Bezier.
+ let z = [0.0035625, 0.0035625 - 0.3125, 20. - 0.625 + 0.0035625];
+ let c = [[0., 0.5, z[0]], [5., 0.5, z[1]], [10., 0.5, z[2]]];
+ let shape = Brep {
+ version: crate::brep::VERSION,
+ shells: vec![Shell {
+ vertices: vec![c[0], c[2]],
+ edges: vec![
+ Edge { vertices: [0, 1], curve: Curve::Spline { knots: vec![0., 0., 0., 1., 1., 1.], points: c.to_vec() } },
+ Edge { vertices: [1, 0], curve: Curve::Line { start: c[2], end: c[0] } },
+ ],
+ faces: vec![Face {
+ loops: vec![vec![uses(0, true), uses(1, true)]],
+ surface: Surface::Plane { origin: c[0], u_axis: [1., 0., 0.], v_axis: [0., 0., 1.] },
+ forward: true,
+ }],
+ }],
+ };
+ let curve = prepare(&shape, &Options::default()).unwrap();
+ let view = View::new(Vec3::new(0., 0., -1.), Vec3::new(0., 1., 0.)).unwrap();
+ let d = hidden_lines(&[patch, curve], &[identity(0, [0.; 3]), identity(1, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ let dip: Vec<&Piece> = edge_line(&d, 1, 0).pieces.iter().filter(|p| p.t[0] < 0.02 && p.t[1] > 0.01).collect();
+ assert!(!dip.is_empty());
+ assert!(dip.iter().all(|p| p.visibility != Visibility::Visible), "{dip:?}");
+}
+
+#[test]
+fn an_arc_that_turns_back_is_drawn_as_chords() {
+ // (10 (1 - u^2), 20 u) / (1 + u^2) with u = 10 (t^3 / 3 - t^2 / 4 + 0.04 t): on the circle
+ // of radius 10, but u falls between t = 0.1 and 0.4, so the edge goes back down to
+ // y = -0.533 before it turns on to 1.78 rad. No single arc draws that: chords, which reach
+ // down there.
+ let u3 = [0., 0.4 / 3., 0.8 / 3. - 2.5 / 3., 0.4 - 2.5 + 10. / 3.];
+ let u = bernstein_product(&u3, &[1.; 4]);
+ let uu = bernstein_product(&u3, &u3);
+ let homogeneous: Vec<[f64; 4]> = (0..7).map(|k| [10. * (1. - uu[k]), 20. * u[k], 0., 1. + uu[k]]).collect();
+ let th = 2. * u3[3].atan();
+ let end = [10. * th.cos(), 10. * th.sin(), 0.];
+ let shape = Brep {
+ version: crate::brep::VERSION,
+ shells: vec![Shell {
+ vertices: vec![[10., 0., 0.], end],
+ edges: vec![
+ Edge { vertices: [0, 1], curve: Curve::RationalSpline { knots: [[0.; 7], [1.; 7]].concat(), homogeneous } },
+ Edge { vertices: [1, 0], curve: Curve::Line { start: end, end: [10., 0., 0.] } },
+ ],
+ faces: vec![Face {
+ loops: vec![vec![uses(0, true), uses(1, true)]],
+ surface: Surface::Plane { origin: [0.; 3], u_axis: [1., 0., 0.], v_axis: [0., 1., 0.] },
+ forward: true,
+ }],
+ }],
+ };
+ let def = prepare(&shape, &Options::default()).unwrap();
+ let view = View::new(Vec3::new(0., 0., -1.), Vec3::new(0., 1., 0.)).unwrap();
+ let d = hidden_lines(&[def], &[identity(0, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ let line = edge_line(&d, 0, 0);
+ assert!(line.pieces.iter().all(|p| matches!(p.accuracy, CurveAccuracy::Sampled { .. })), "{:?}", line.pieces);
+ let low = line.pieces.iter().flat_map(|p| p.geometry.iter()).map(|g| g.point_at(0.).y.min(g.point_at(1.).y)).fold(f64::MAX, f64::min);
+ assert!(low < -0.5, "the chords reach down to y = {low}");
+}
+
+#[test]
+fn a_cone_tip_trimmed_near_the_apex_is_only_its_tip() {
+ // A cone record of slope 0.25 from its apex up to 10 m, trimmed by a circle at z = 1 to the
+ // tip below it: a box edge at x = 40, z = 50 to 150, seen along +X, is in front of nothing.
+ let tau = std::f64::consts::TAU;
+ let tip = Brep {
+ version: crate::brep::VERSION,
+ shells: vec![Shell {
+ vertices: vec![[0.25, 0., 1.]],
+ edges: vec![circle([0., 0., 1.], 0.25, 0)],
+ faces: vec![Face {
+ loops: vec![vec![uses(0, false)]],
+ surface: Surface::Cone {
+ frame: frame_at([0.; 3]),
+ radius_at_origin: 0.,
+ half_angle: 0.25f64.atan(),
+ angle: [0., tau],
+ height: [0., 10_000.],
+ },
+ forward: true,
+ }],
+ }],
+ };
+ let tip = prepare(&tip, &Options::default()).unwrap();
+ let bar = prepare(&cuboid([40., -1., 50.], [41., 1., 150.]), &Options::default()).unwrap();
+ let view = View::new(Vec3::new(1., 0., 0.), Vec3::new(0., 0., 1.)).unwrap();
+ let d = hidden_lines(&[tip, bar], &[identity(0, [0.; 3]), identity(1, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ // Edges 8 and 10 run along z at x = 40, the side facing the viewer.
+ for e in [8, 10] {
+ let states: Vec<Visibility> = edge_line(&d, 1, e).pieces.iter().map(|p| p.visibility).collect();
+ assert!(states.iter().all(|v| *v == Visibility::Visible), "edge {e}: {states:?}");
+ }
+}
+
+#[test]
+fn an_edge_behind_a_left_out_freeform_face_is_uncertain_there() {
+ // A freeform tube about the vertical line x = 10 (radius 2.5 at its ends, 2.75 halfway up,
+ // a quadratic profile) in front of a long box edge at z = 5. Its silhouettes are left out,
+ // so nothing cuts the edge where the tube covers it (x from 7.25 to 12.75); that part may
+ // be hidden and must not come out visible.
+ let tau = std::f64::consts::TAU;
+ let profile = Curve::Spline { knots: vec![0., 0., 0., 1., 1., 1.], points: vec![[12.5, 0., 0.], [13., 0., 5.], [12.5, 0., 10.]] };
+ let tube = Brep {
+ version: crate::brep::VERSION,
+ shells: vec![Shell {
+ vertices: vec![[12.5, 0., 0.], [12.5, 0., 10.]],
+ edges: vec![circle([10., 0., 0.], 2.5, 0), circle([10., 0., 10.], 2.5, 1), Edge { vertices: [0, 1], curve: profile.clone() }],
+ faces: vec![Face {
+ loops: vec![vec![uses(0, true), uses(2, true), uses(1, false), uses(2, false)]],
+ surface: Surface::Revolution { profile: Box::new(profile), origin: [10., 0., 0.], axis: [0., 0., 1.], angle: [0., tau] },
+ forward: true,
+ }],
+ }],
+ };
+ let tube = prepare(&tube, &Options::default()).unwrap();
+ assert_eq!(tube.report.freeform_faces, vec![0]);
+ let bar = prepare(&cuboid([-50., 4., 4.], [50., 6., 5.]), &Options::default()).unwrap();
+ let view = View::new(Vec3::new(0., 1., 0.), Vec3::new(0., 0., 1.)).unwrap();
+ let d = hidden_lines(&[tube, bar], &[identity(0, [0.; 3]), identity(1, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ // Edge 2 joins corners 4 (-50, 4, 5) and 5 (50, 4, 5): x = 100 t - 50.
+ for p in &edge_line(&d, 1, 2).pieces {
+ let (x0, x1) = (100. * p.t[0] - 50., 100. * p.t[1] - 50.);
+ if x1 > 7.25 && x0 < 12.75 {
+ assert_ne!(p.visibility, Visibility::Visible, "x {x0}..{x1}");
+ }
+ if x1 < 6. || x0 > 14. {
+ assert_eq!(p.visibility, Visibility::Visible, "x {x0}..{x1}");
+ }
+ }
+}
+
+#[test]
+fn a_sloping_edge_that_runs_behind_a_left_out_face_is_uncertain() {
+ // Over the twisted patch (z = 0.5 along y = 0), seen from above, a sloping strip's edge runs
+ // from (-4, 0, 2) down to (4, 0, 0.4): in front of the patch at its middle, behind it past
+ // x = 3.5. All of it lies in the patch's screen box, so nothing cuts it there.
+ let patch = prepare(&twisted_patch(), &Options::default()).unwrap();
+ let c = [[-4., 0., 2.], [4., 0., 0.4], [4., 0.2, 0.4], [-4., 0.2, 2.]];
+ let edges =
+ (0..4).map(|i| Edge { vertices: [i as u32, ((i + 1) % 4) as u32], curve: Curve::Line { start: c[i], end: c[(i + 1) % 4] } }).collect();
+ let face = Face {
+ loops: vec![(0..4).map(|e| uses(e, true)).collect()],
+ surface: Surface::Plane { origin: c[0], u_axis: [8., 0., -1.6], v_axis: [0., 0.2, 0.] },
+ forward: true,
+ };
+ let strip =
+ prepare(&Brep { version: crate::brep::VERSION, shells: vec![Shell { vertices: c.to_vec(), edges, faces: vec![face] }] }, &Options::default())
+ .unwrap();
+ let view = View::new(Vec3::new(0., 0., -1.), Vec3::new(0., 1., 0.)).unwrap();
+ let d = hidden_lines(&[patch, strip], &[identity(0, [0.; 3]), identity(1, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ for p in &edge_line(&d, 1, 0).pieces {
+ if 8. * p.t[1] - 4. > 3.6 {
+ assert_ne!(p.visibility, Visibility::Visible, "{p:?}");
+ }
+ }
+}
+
+#[test]
+fn a_torus_stored_as_a_rational_spline_patch_is_recognised() {
+ // The patch of a torus R 20, r 5 with longitude and meridian both from -pi/4 to pi/4, as a
+ // degree (2, 2) rational spline, seen along the axis: a torus, not a freeform face, and the
+ // outer equator inside it is an exact silhouette arc of radius 25.
+ let (big, small) = (20., 5.);
+ let q = std::f64::consts::FRAC_PI_4;
+ let s2 = std::f64::consts::SQRT_2;
+ // The unit arc from -45 to 45 degrees: its control points and weights.
+ let arc = [([q.cos(), -q.sin()], 1.), ([s2, 0.], q.cos()), ([q.cos(), q.sin()], 1.)];
+ let homogeneous: Vec<Vec<[f64; 4]>> = arc
+ .iter()
+ .map(|(ci, wi)| {
+ arc.iter()
+ .map(|(mj, wj)| {
+ let (rho, h, w) = (big + small * mj[0], small * mj[1], wi * wj);
+ [rho * ci[0] * w, rho * ci[1] * w, h * w, w]
+ })
+ .collect()
+ })
+ .collect();
+ let at = |t: f64, f: f64| [(big + small * f.cos()) * t.cos(), (big + small * f.cos()) * t.sin(), small * f.sin()];
+ let parallel = |f: f64| crate::brep::Frame { origin: [0., 0., small * f.sin()], x_axis: [1., 0., 0.], y_axis: [0., 1., 0.] };
+ let meridian = |t: f64| crate::brep::Frame { origin: [big * t.cos(), big * t.sin(), 0.], x_axis: [t.cos(), t.sin(), 0.], y_axis: [0., 0., 1.] };
+ let edges = vec![
+ Edge { vertices: [0, 1], curve: Curve::CircleArc { frame: parallel(-q), radius: big + small * q.cos(), angle: [-q, q] } },
+ Edge { vertices: [1, 2], curve: Curve::CircleArc { frame: meridian(q), radius: small, angle: [-q, q] } },
+ Edge { vertices: [3, 2], curve: Curve::CircleArc { frame: parallel(q), radius: big + small * q.cos(), angle: [-q, q] } },
+ Edge { vertices: [0, 3], curve: Curve::CircleArc { frame: meridian(-q), radius: small, angle: [-q, q] } },
+ ];
+ let face = Face {
+ loops: vec![vec![uses(0, true), uses(1, true), uses(2, false), uses(3, false)]],
+ surface: Surface::RationalSpline { u_knots: vec![0., 0., 0., 1., 1., 1.], v_knots: vec![0., 0., 0., 1., 1., 1.], homogeneous },
+ forward: true,
+ };
+ let patch = Brep {
+ version: crate::brep::VERSION,
+ shells: vec![Shell { vertices: vec![at(-q, -q), at(q, -q), at(q, q), at(-q, q)], edges, faces: vec![face] }],
+ };
+ let def = prepare(&patch, &Options::default()).unwrap();
+ assert!(def.report.freeform_faces.is_empty(), "{:?}", def.report);
+ let view = View::new(Vec3::new(0., 0., -1.), Vec3::new(0., 1., 0.)).unwrap();
+ let d = hidden_lines(&[def], &[identity(0, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ assert!(d.unsupported.is_empty());
+ let mut length = 0.;
+ for p in silhouette_pieces(&d) {
+ assert_eq!(p.accuracy, CurveAccuracy::Analytic);
+ for g in &p.geometry {
+ for k in 0..=8 {
+ assert!((g.point_at(k as f64 / 8.).len() - 25.).abs() < 1e-6, "{g:?}");
+ }
+ length += (0..16).map(|k| g.point_at(k as f64 / 16.).dist(g.point_at((k + 1) as f64 / 16.))).sum::<f64>();
+ }
+ }
+ assert!((length - 25. * std::f64::consts::FRAC_PI_2).abs() < 0.01, "{length} mm of outline");
+}
+
+#[test]
+fn a_torus_patch_with_a_bump_in_a_narrow_knot_span_is_not_taken_for_a_torus() {
+ // The torus patch R 20, r 5 again, its longitude in three spans, the middle one 0.002 of
+ // the parameters wide; one control point there pushed out by 0.2 %. Between the sample
+ // grid's points, but not between the checks on every knot span.
+ let (big, small) = (20., 5.);
+ let q = std::f64::consts::FRAC_PI_4;
+ let s2 = std::f64::consts::SQRT_2;
+ let ts = [-q, -q + 0.3, -q + 0.5, q];
+ let mut lon: Vec<([f64; 2], f64)> = vec![([ts[0].cos(), ts[0].sin()], 1.)];
+ for w in ts.windows(2) {
+ let (m, h) = (0.5 * (w[0] + w[1]), 0.5 * (w[1] - w[0]));
+ lon.push(([m.cos() / h.cos(), m.sin() / h.cos()], h.cos()));
+ lon.push(([w[1].cos(), w[1].sin()], 1.));
+ }
+ let mer = [([q.cos(), -q.sin()], 1.), ([s2, 0.], q.cos()), ([q.cos(), q.sin()], 1.)];
+ let homogeneous: Vec<Vec<[f64; 4]>> = lon
+ .iter()
+ .enumerate()
+ .map(|(i, (ci, wi))| {
+ mer.iter()
+ .enumerate()
+ .map(|(j, (mj, wj))| {
+ let bump = if (i, j) == (3, 1) { 1.002 } else { 1. };
+ let (rho, h, w) = ((big + small * mj[0]) * bump, small * mj[1], wi * wj);
+ [rho * ci[0] * w, rho * ci[1] * w, h * w, w]
+ })
+ .collect()
+ })
+ .collect();
+ let at = |t: f64, f: f64| [(big + small * f.cos()) * t.cos(), (big + small * f.cos()) * t.sin(), small * f.sin()];
+ let parallel = |f: f64| crate::brep::Frame { origin: [0., 0., small * f.sin()], x_axis: [1., 0., 0.], y_axis: [0., 1., 0.] };
+ let meridian = |t: f64| crate::brep::Frame { origin: [big * t.cos(), big * t.sin(), 0.], x_axis: [t.cos(), t.sin(), 0.], y_axis: [0., 0., 1.] };
+ let edges = vec![
+ Edge { vertices: [0, 1], curve: Curve::CircleArc { frame: parallel(-q), radius: big + small * q.cos(), angle: [-q, q] } },
+ Edge { vertices: [1, 2], curve: Curve::CircleArc { frame: meridian(q), radius: small, angle: [-q, q] } },
+ Edge { vertices: [3, 2], curve: Curve::CircleArc { frame: parallel(q), radius: big + small * q.cos(), angle: [-q, q] } },
+ Edge { vertices: [0, 3], curve: Curve::CircleArc { frame: meridian(-q), radius: small, angle: [-q, q] } },
+ ];
+ let face = Face {
+ loops: vec![vec![uses(0, true), uses(1, true), uses(2, false), uses(3, false)]],
+ surface: Surface::RationalSpline {
+ u_knots: vec![0., 0., 0., 0.1, 0.1, 0.102, 0.102, 1., 1., 1.],
+ v_knots: vec![0., 0., 0., 1., 1., 1.],
+ homogeneous,
+ },
+ forward: true,
+ };
+ let patch = Brep {
+ version: crate::brep::VERSION,
+ shells: vec![Shell { vertices: vec![at(-q, -q), at(q, -q), at(q, q), at(-q, q)], edges, faces: vec![face] }],
+ };
+ let def = prepare(&patch, &Options::default()).unwrap();
+ assert_eq!(def.report.freeform_faces, vec![0], "{:?}", def.report);
+}
+
+#[test]
+fn a_big_circle_passing_behind_a_thin_left_out_face_is_uncertain_there() {
+ // A disc of radius 5000 whose edge passes under a freeform tube (radius 0.01 to about
+ // 0.02, a cubic profile) lying along Y over (5000, 0), with a cube 9 km away making the scene coarse. The edge is turned so
+ // that its samples on either side of the tube are 30 mm away at x = 4999.905: the chord
+ // between them misses the tube's box by less than its sag, crossing none of its sides.
+ let tau = std::f64::consts::TAU;
+ let turn = 8.5 * std::f64::consts::PI / 256.;
+ let (c, sn) = (turn.cos(), turn.sin());
+ let frame = crate::brep::Frame { origin: [0.; 3], x_axis: [-c, -sn, 0.], y_axis: [sn, -c, 0.] };
+ let disc = Brep {
+ version: crate::brep::VERSION,
+ shells: vec![Shell {
+ vertices: vec![[-5000. * c, -5000. * sn, 0.]],
+ edges: vec![Edge { vertices: [0, 0], curve: Curve::CircleArc { frame, radius: 5000., angle: [0., tau] } }],
+ faces: vec![Face {
+ loops: vec![vec![uses(0, true)]],
+ surface: Surface::Plane { origin: [0.; 3], u_axis: [1., 0., 0.], v_axis: [0., 1., 0.] },
+ forward: true,
+ }],
+ }],
+ };
+ let profile = Curve::Spline {
+ knots: vec![0., 0., 0., 0., 1., 1., 1., 1.],
+ points: vec![[5000.01, -100., 1.], [5000.03, -33., 1.], [5000.01, 33., 1.], [5000.01, 100., 1.]],
+ };
+ let end = |y: f64, v: u32| Edge {
+ vertices: [v, v],
+ curve: Curve::CircleArc {
+ frame: crate::brep::Frame { origin: [5000., y, 1.], x_axis: [1., 0., 0.], y_axis: [0., 0., 1.] },
+ radius: 0.01,
+ angle: [0., tau],
+ },
+ };
+ let tube = Brep {
+ version: crate::brep::VERSION,
+ shells: vec![Shell {
+ vertices: vec![[5000.01, -100., 1.], [5000.01, 100., 1.]],
+ edges: vec![end(-100., 0), end(100., 1), Edge { vertices: [0, 1], curve: profile.clone() }],
+ faces: vec![Face {
+ loops: vec![vec![uses(0, true), uses(2, true), uses(1, false), uses(2, false)]],
+ surface: Surface::Revolution { profile: Box::new(profile), origin: [5000., 0., 1.], axis: [0., 1., 0.], angle: [0., tau] },
+ forward: true,
+ }],
+ }],
+ };
+ let defs = [
+ prepare(&tube, &Options::default()).unwrap(),
+ prepare(&disc, &Options::default()).unwrap(),
+ prepare(&cuboid([9e6, 0., 0.], [9e6 + 1., 1., 1.]), &Options::default()).unwrap(),
+ ];
+ assert_eq!(defs[0].report.freeform_faces, vec![0]);
+ let view = View::new(Vec3::new(0., 0., -1.), Vec3::new(0., 1., 0.)).unwrap();
+ let d = hidden_lines(&defs, &[identity(0, [0.; 3]), identity(1, [0.; 3]), identity(2, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ // The disc's edge reaches (5000, 0) at the parameter pi - turn.
+ let at = std::f64::consts::PI - turn;
+ let under: Vec<&Piece> = edge_line(&d, 1, 0).pieces.iter().filter(|p| p.t[0] <= at && p.t[1] >= at).collect();
+ assert!(!under.is_empty());
+ assert!(under.iter().all(|p| p.visibility != Visibility::Visible), "{under:?}");
+}
+
+#[test]
+fn a_torus_in_two_halves_keeps_whole_outlines_with_fine_trims() {
+ // Seen along (0, 1, -1) the traced outline's chords stand up to their deviation off the
+ // torus; with a finer trim (768 samples a span) the boundary tolerance is smaller than
+ // that, and the outline must still not break into gaps.
+ let def = |n: usize| prepare(&torus(20., 5.), &Options { trim_samples: n, ..Options::default() }).unwrap();
+ let view = View::new(Vec3::new(0., 1., -1.), Vec3::new(0., 0., 1.)).unwrap();
+ let count = |n: usize| {
+ hidden_lines(&[def(n)], &[identity(0, [0.; 3])], &view, &Options { trim_samples: n, ..Options::default() }, &never).unwrap().stats.silhouettes
+ };
+ assert_eq!(count(768), count(256));
+}
+
+#[test]
+fn an_arc_folding_back_under_a_left_out_face_seen_edge_on_is_uncertain_there() {
+ // An arc of radius 10000 in the XZ plane, seen from above: its projection lies on the X axis
+ // and turns back at x = 10000 a quarter of the way into its first sample step, so the chord
+ // between its first samples (x 9999.953 and 9999.577) has no sag and stops short of the
+ // turn. A tiny freeform patch above x = 10000 covers the turn. The arc's angles are counted
+ // from 0 and from 8 pi.
+ for turns in [0., 4.] {
+ folding_arc_under_a_patch(turns * std::f64::consts::TAU);
+ }
+}
+
+fn folding_arc_under_a_patch(offset: f64) {
+ let step = std::f64::consts::PI / 256.;
+ let ta = -step / 4. + offset;
+ let frame = crate::brep::Frame { origin: [0.; 3], x_axis: [1., 0., 0.], y_axis: [0., 0., 1.] };
+ let at = |t: f64| [10000. * t.cos(), 0., 10000. * t.sin()];
+ let (start, end) = (at(ta), at(ta + std::f64::consts::PI / 8.));
+ let arc = Brep {
+ version: crate::brep::VERSION,
+ shells: vec![Shell {
+ vertices: vec![start, end],
+ edges: vec![
+ Edge { vertices: [0, 1], curve: Curve::CircleArc { frame, radius: 10000., angle: [ta, ta + std::f64::consts::PI / 8.] } },
+ Edge { vertices: [1, 0], curve: Curve::Line { start: end, end: start } },
+ ],
+ faces: vec![Face {
+ loops: vec![vec![uses(0, true), uses(1, true)]],
+ surface: Surface::Plane { origin: [0.; 3], u_axis: [1., 0., 0.], v_axis: [0., 0., 1.] },
+ forward: true,
+ }],
+ }],
+ };
+ let (x0, x1, y0, y1) = (9999.98, 10000.02, -0.02, 0.02);
+ let p = [[x0, y0, 1.], [x1, y0, 1.0004], [x1, y1, 1.], [x0, y1, 1.0004]];
+ let edges =
+ (0..4).map(|i| Edge { vertices: [i as u32, ((i + 1) % 4) as u32], curve: Curve::Line { start: p[i], end: p[(i + 1) % 4] } }).collect();
+ let face = Face {
+ loops: vec![(0..4).map(|e| uses(e, true)).collect()],
+ surface: Surface::Spline { u_knots: vec![0., 0., 1., 1.], v_knots: vec![0., 0., 1., 1.], points: vec![vec![p[0], p[3]], vec![p[1], p[2]]] },
+ forward: true,
+ };
+ let patch = Brep { version: crate::brep::VERSION, shells: vec![Shell { vertices: p.to_vec(), edges, faces: vec![face] }] };
+ let defs = [prepare(&patch, &Options::default()).unwrap(), prepare(&arc, &Options::default()).unwrap()];
+ assert_eq!(defs[0].report.freeform_faces, vec![0]);
+ let view = View::new(Vec3::new(0., 0., -1.), Vec3::new(0., 1., 0.)).unwrap();
+ let d = hidden_lines(&defs, &[identity(0, [0.; 3]), identity(1, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ let turn: Vec<&Piece> = edge_line(&d, 1, 0).pieces.iter().filter(|p| p.t[0] <= offset && p.t[1] >= offset).collect();
+ assert!(!turn.is_empty());
+ assert!(turn.iter().all(|p| p.visibility != Visibility::Visible), "{turn:?}");
+}
+
+#[test]
+fn a_left_out_face_curling_over_its_own_edge_makes_it_uncertain() {
+ // A freeform patch X = 1000 u (u - 0.5), Y = 8000 v, Z = 0.01 u seen from above: at u = 0.5
+ // it passes back over its own edge u = 0, 0.005 mm above it, closer than the own-face
+ // margin of the ray test. The edge may be hidden.
+ let (a, b, c) = ([0., 0.], [-250., 0.005], [500., 0.01]);
+ let at = |q: [f64; 2], y: f64| [q[0], y, q[1]];
+ let edges = vec![
+ Edge { vertices: [0, 1], curve: Curve::Spline { knots: vec![0., 0., 0., 1., 1., 1.], points: vec![at(a, 0.), at(b, 0.), at(c, 0.)] } },
+ Edge { vertices: [1, 2], curve: Curve::Line { start: at(c, 0.), end: at(c, 8000.) } },
+ Edge {
+ vertices: [3, 2],
+ curve: Curve::Spline { knots: vec![0., 0., 0., 1., 1., 1.], points: vec![at(a, 8000.), at(b, 8000.), at(c, 8000.)] },
+ },
+ Edge { vertices: [0, 3], curve: Curve::Line { start: at(a, 0.), end: at(a, 8000.) } },
+ ];
+ let face = Face {
+ loops: vec![vec![uses(0, true), uses(1, true), uses(2, false), uses(3, false)]],
+ surface: Surface::Spline {
+ u_knots: vec![0., 0., 0., 1., 1., 1.],
+ v_knots: vec![0., 0., 1., 1.],
+ points: vec![vec![at(a, 0.), at(a, 8000.)], vec![at(b, 0.), at(b, 8000.)], vec![at(c, 0.), at(c, 8000.)]],
+ },
+ forward: true,
+ };
+ let sheet = Brep {
+ version: crate::brep::VERSION,
+ shells: vec![Shell { vertices: vec![at(a, 0.), at(c, 0.), at(c, 8000.), at(a, 8000.)], edges, faces: vec![face] }],
+ };
+ let def = prepare(&sheet, &Options::default()).unwrap();
+ assert_eq!(def.report.freeform_faces, vec![0]);
+ let view = View::new(Vec3::new(0., 0., -1.), Vec3::new(0., 1., 0.)).unwrap();
+ let d = hidden_lines(&[def], &[identity(0, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ let states: Vec<Visibility> = edge_line(&d, 0, 3).pieces.iter().map(|p| p.visibility).collect();
+ assert!(states.iter().all(|v| *v != Visibility::Visible), "{states:?}");
+}
+
+#[test]
+fn a_plate_just_above_a_box_in_a_large_scene_is_not_looked_through() {
+ // A box with its top at z = 0, a larger plate 0.005 mm above it and a cube 1e7 mm away:
+ // the box's top edges are under the plate and must not come out visible.
+ let defs = [
+ prepare(&cuboid([0., 0., -10.], [10., 10., 0.]), &Options::default()).unwrap(),
+ prepare(&cuboid([-5., -5., 0.005], [15., 15., 0.007]), &Options::default()).unwrap(),
+ prepare(&cuboid([1e7, 0., 0.], [1e7 + 1., 1., 1.]), &Options::default()).unwrap(),
+ ];
+ let view = View::new(Vec3::new(0., 0., -1.), Vec3::new(0., 1., 0.)).unwrap();
+ let d = hidden_lines(&defs, &[identity(0, [0.; 3]), identity(1, [0.; 3]), identity(2, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ // Edges 2, 3, 6 and 7 of the box run along its top face.
+ for e in [2, 3, 6, 7] {
+ let states: Vec<Visibility> = edge_line(&d, 0, e).pieces.iter().map(|p| p.visibility).collect();
+ assert!(states.iter().all(|v| *v != Visibility::Visible), "edge {e}: {states:?}");
+ }
+}
+
+#[test]
+fn a_sphere_with_a_spline_band_between_record_caps_is_one_sphere() {
+ // A sphere of radius 10: a rational spline band all the way round between the latitudes
+ // -45 and 45 degrees, and two sphere records as caps, meeting at circles of radius 7.07.
+ // The band is recognised as the same sphere, so those circles are seams: seen along the
+ // axis only the outline of radius 10 is drawn.
+ let (r, q, s) = (10., std::f64::consts::FRAC_PI_4, std::f64::consts::FRAC_1_SQRT_2);
+ let ring = [
+ ([1., 0.], 1.),
+ ([1., 1.], s),
+ ([0., 1.], 1.),
+ ([-1., 1.], s),
+ ([-1., 0.], 1.),
+ ([-1., -1.], s),
+ ([0., -1.], 1.),
+ ([1., -1.], s),
+ ([1., 0.], 1.),
+ ];
+ let lat = [([r * q.cos(), -r * q.sin()], 1.), ([r / q.cos(), 0.], q.cos()), ([r * q.cos(), r * q.sin()], 1.)];
+ let homogeneous: Vec<Vec<[f64; 4]>> = ring
+ .iter()
+ .map(|(ci, wi)| lat.iter().map(|(pj, wj)| [pj[0] * ci[0] * wi * wj, pj[0] * ci[1] * wi * wj, pj[1] * wi * wj, wi * wj]).collect())
+ .collect();
+ let z = r * q.sin();
+ let rho = r * q.cos();
+ let tau = std::f64::consts::TAU;
+ let half = std::f64::consts::FRAC_PI_2;
+ let cap = |latitude: [f64; 2], e: u32, forward: bool| Face {
+ loops: vec![vec![uses(e, forward)]],
+ surface: Surface::Sphere { frame: frame_at([0.; 3]), radius: r, longitude: [0., tau], latitude },
+ forward: true,
+ };
+ let band = Face {
+ loops: vec![vec![uses(0, true)], vec![uses(1, false)]],
+ surface: Surface::RationalSpline {
+ u_knots: vec![0., 0., 0., 0.25, 0.25, 0.5, 0.5, 0.75, 0.75, 1., 1., 1.],
+ v_knots: vec![0., 0., 0., 1., 1., 1.],
+ homogeneous,
+ },
+ forward: true,
+ };
+ let body = Brep {
+ version: crate::brep::VERSION,
+ shells: vec![Shell {
+ vertices: vec![[rho, 0., -z], [rho, 0., z]],
+ edges: vec![circle([0., 0., -z], rho, 0), circle([0., 0., z], rho, 1)],
+ faces: vec![band, cap([q, half], 1, true), cap([-half, -q], 0, false)],
+ }],
+ };
+ let def = prepare(&body, &Options::default()).unwrap();
+ assert_eq!(def.report.surfaces.get("sphere"), Some(&3), "{:?}", def.report);
+ let view = View::new(Vec3::new(0., 0., -1.), Vec3::new(0., 1., 0.)).unwrap();
+ let d = hidden_lines(&[def], &[identity(0, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ for p in pieces(&d).filter(|p| p.visibility == Visibility::Visible && !p.covered) {
+ for g in &p.geometry {
+ let radius = g.point_at(0.5).len();
+ assert!((radius - 10.).abs() < 1e-6, "a line at radius {radius}");
+ }
+ }
+}
+
+#[test]
+fn chords_of_a_racing_circle_stay_within_their_stated_deviation() {
+ // z^6 / |z|^6 with z = 0.01 (1 - t) + (1 + i sqrt 3) t: the unit circle, its weights
+ // 1e-12 to 64 apart, so drawn as chords; a cube 9 km away makes the scene coarse. Every
+ // point of the circle must lie within the chords' stated deviation of them.
+ let c1 = (1f64, 3f64.sqrt());
+ let mut num = Vec::new();
+ let mut pw = (1f64, 0f64);
+ for k in 0..=6 {
+ num.push((0.01f64.powi(6 - k) * pw.0, 0.01f64.powi(6 - k) * pw.1));
+ pw = (pw.0 * c1.0 - pw.1 * c1.1, pw.0 * c1.1 + pw.1 * c1.0);
+ }
+ let q = [1e-4, 0.01, 4.];
+ let w = bernstein_product(&bernstein_product(&q, &q), &q);
+ let homogeneous: Vec<[f64; 4]> = num.iter().zip(&w).map(|((re, im), w)| [*re, *im, 0., *w]).collect();
+ let disc = Brep {
+ version: crate::brep::VERSION,
+ shells: vec![Shell {
+ vertices: vec![[1., 0., 0.]],
+ edges: vec![Edge { vertices: [0, 0], curve: Curve::RationalSpline { knots: [[0.; 7], [1.; 7]].concat(), homogeneous } }],
+ faces: vec![Face {
+ loops: vec![vec![uses(0, true)]],
+ surface: Surface::Plane { origin: [0.; 3], u_axis: [1., 0., 0.], v_axis: [0., 1., 0.] },
+ forward: true,
+ }],
+ }],
+ };
+ let defs = [prepare(&disc, &Options::default()).unwrap(), prepare(&cuboid([9e6, 0., 0.], [9e6 + 1., 1., 1.]), &Options::default()).unwrap()];
+ let view = View::new(Vec3::new(0., 0., -1.), Vec3::new(0., 1., 0.)).unwrap();
+ let d = hidden_lines(&defs, &[identity(0, [0.; 3]), identity(1, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ let line = edge_line(&d, 0, 0);
+ if turn_or_chords(line.pieces.iter()).is_some() {
+ return;
+ }
+ let dev = line
+ .pieces
+ .iter()
+ .filter_map(|p| if let CurveAccuracy::Sampled { max_sample_deviation_mm: v } = p.accuracy { Some(v) } else { None })
+ .fold(0., f64::max);
+ let chords: Vec<(Vec2, Vec2)> =
+ line.pieces.iter().flat_map(|p| p.geometry.iter()).filter_map(|g| if let Seg2::Line { a, b } = *g { Some((a, b)) } else { None }).collect();
+ for k in 0..720 {
+ let t = std::f64::consts::TAU * k as f64 / 720.;
+ let q = Vec2::new(t.cos(), t.sin());
+ let gap = chords.iter().map(|(a, b)| point_segment([q.x, q.y], [a.x, a.y], [b.x, b.y])).fold(f64::MAX, f64::min);
+ assert!(gap <= dev + 1e-6, "({}, {}) is {gap} mm from the chords, stated {dev}", q.x, q.y);
+ }
+}
+
+#[test]
+fn a_big_arc_is_cut_where_it_meets_a_left_out_faces_box() {
+ // An arc of radius 10000 (angles -pi/8 to 0) under a freeform tube lying along Y at
+ // x = 9990 (radius about 2.5, a cubic profile), a cube 9 km away making the scene coarse:
+ // no visible piece of the arc may reach under the tube.
+ let tau = std::f64::consts::TAU;
+ let a0 = -std::f64::consts::PI / 8.;
+ let (start, end) = ([10000. * a0.cos(), 10000. * a0.sin(), 0.], [10000., 0., 0.]);
+ let arc = Brep {
+ version: crate::brep::VERSION,
+ shells: vec![Shell {
+ vertices: vec![start, end],
+ edges: vec![
+ Edge { vertices: [0, 1], curve: Curve::CircleArc { frame: frame_at([0.; 3]), radius: 10000., angle: [a0, 0.] } },
+ Edge { vertices: [1, 0], curve: Curve::Line { start: end, end: start } },
+ ],
+ faces: vec![Face {
+ loops: vec![vec![uses(0, true), uses(1, true)]],
+ surface: Surface::Plane { origin: [0.; 3], u_axis: [1., 0., 0.], v_axis: [0., 1., 0.] },
+ forward: true,
+ }],
+ }],
+ };
+ let x = 9990.;
+ let profile = Curve::Spline {
+ knots: vec![0., 0., 0., 0., 1., 1., 1., 1.],
+ points: vec![[x + 2.5, -4000., 1.], [x + 2.504, -4000. / 3., 1.], [x + 2.5, 2000. / 3., 1.], [x + 2.5, 3000., 1.]],
+ };
+ let end_circle = |y: f64, v: u32| Edge {
+ vertices: [v, v],
+ curve: Curve::CircleArc {
+ frame: crate::brep::Frame { origin: [x, y, 1.], x_axis: [1., 0., 0.], y_axis: [0., 0., 1.] },
+ radius: 2.5,
+ angle: [0., tau],
+ },
+ };
+ let tube = Brep {
+ version: crate::brep::VERSION,
+ shells: vec![Shell {
+ vertices: vec![[x + 2.5, -4000., 1.], [x + 2.5, 3000., 1.]],
+ edges: vec![end_circle(-4000., 0), end_circle(3000., 1), Edge { vertices: [0, 1], curve: profile.clone() }],
+ faces: vec![Face {
+ loops: vec![vec![uses(0, true), uses(2, true), uses(1, false), uses(2, false)]],
+ surface: Surface::Revolution { profile: Box::new(profile), origin: [x, 0., 1.], axis: [0., 1., 0.], angle: [0., tau] },
+ forward: true,
+ }],
+ }],
+ };
+ let defs = [
+ prepare(&tube, &Options::default()).unwrap(),
+ prepare(&arc, &Options::default()).unwrap(),
+ prepare(&cuboid([9e6, 0., 0.], [9e6 + 1., 1., 1.]), &Options::default()).unwrap(),
+ ];
+ assert_eq!(defs[0].report.freeform_faces, vec![0]);
+ let view = View::new(Vec3::new(0., 0., -1.), Vec3::new(0., 1., 0.)).unwrap();
+ let d = hidden_lines(&defs, &[identity(0, [0.; 3]), identity(1, [0.; 3]), identity(2, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ for p in edge_line(&d, 1, 0).pieces.iter().filter(|p| p.visibility == Visibility::Visible) {
+ for k in 0..=400 {
+ let t = p.t[0] + (p.t[1] - p.t[0]) * k as f64 / 400.;
+ let (px, py) = (10000. * t.cos(), 10000. * t.sin());
+ let under = px > x - 2.5 && px < x + 2.5 && py > -4000. && py < 3000.;
+ assert!(!under, "visible at ({px}, {py}), t {t}, piece {:?}", p.t);
+ }
+ }
+}
+
+#[test]
+fn narrow_torus_strips_keep_their_outline() {
+ // Two strips of a torus R 20, r 10 between the meridian angles 0.3002, 0.3005 and 0.3008,
+ // seen from the side: each side of the outline is a 0.006 mm piece of the circle traced on
+ // the whole torus, whose chords are far longer than the strips are wide.
+ let tau = std::f64::consts::TAU;
+ let ring = |phi: f64, v: u32| circle([0., 0., 10. * phi.sin()], 20. + 10. * phi.cos(), v);
+ let strip = |m: [f64; 2], e: [u32; 2]| Face {
+ loops: vec![vec![uses(e[0], true)], vec![uses(e[1], false)]],
+ surface: Surface::Torus { frame: frame_at([0.; 3]), major_radius: 20., minor_radius: 10., longitude: [0., tau], meridian: m },
+ forward: true,
+ };
+ let phis: [f64; 3] = [0.3002, 0.3005, 0.3008];
+ let body = Brep {
+ version: crate::brep::VERSION,
+ shells: vec![Shell {
+ vertices: phis.iter().map(|p| [20. + 10. * p.cos(), 0., 10. * p.sin()]).collect(),
+ edges: vec![ring(phis[0], 0), ring(phis[1], 1), ring(phis[2], 2)],
+ faces: vec![strip([phis[0], phis[1]], [0, 1]), strip([phis[1], phis[2]], [1, 2])],
+ }],
+ };
+ let def = prepare(&body, &Options::default()).unwrap();
+ let view = View::new(Vec3::new(0., 1., 0.), Vec3::new(0., 0., 1.)).unwrap();
+ let d = hidden_lines(&[def], &[identity(0, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ for side in [-1., 1.] {
+ let drawn: f64 = silhouette_pieces(&d)
+ .iter()
+ .filter(|p| p.visibility == Visibility::Visible && !p.covered)
+ .flat_map(|p| p.geometry.iter())
+ .filter(|g| g.point_at(0.5).x * side > 0.)
+ .map(|g| g.point_at(0.).dist(g.point_at(1.)))
+ .sum();
+ assert!((drawn - 0.006).abs() < 1e-4, "side {side}: {drawn} mm of outline");
+ }
+}
+
+#[test]
+fn mirrored_placements_bad_indices_and_bad_views_are_refused() {
+ let def = prepare(&cuboid([0.; 3], [1.; 3]), &Options::default()).unwrap();
+ let view = View::new(Vec3::new(-1., -1., -1.), Vec3::new(0., 0., 1.)).unwrap();
+ let mirror =
+ Placement { body: 0, rotation: [Vec3::new(-1., 0., 0.), Vec3::new(0., 1., 0.), Vec3::new(0., 0., 1.)], translation: Vec3::new(0., 0., 0.) };
+ let defs = [def];
+ assert!(matches!(hidden_lines(&defs, &[mirror], &view, &Options::default(), &never), Err(HlrError::Invalid(_))));
+ assert!(matches!(hidden_lines(&defs, &[identity(3, [0.; 3])], &view, &Options::default(), &never), Err(HlrError::Invalid(_))));
+ assert!(matches!(hidden_lines(&defs, &[identity(0, [f64::NAN, 0., 0.])], &view, &Options::default(), &never), Err(HlrError::Invalid(_))));
+ assert!(View::new(Vec3::new(0., 0., 0.), Vec3::new(0., 0., 1.)).is_err());
+ assert!(View::new(Vec3::new(0., 0., 1.), Vec3::new(0., 0., 2.)).is_err());
+}
+
+#[test]
+fn cancellation_and_budgets_return_errors() {
+ let def = prepare(&cylinder(10., 30.), &Options::default()).unwrap();
+ let view = View::new(Vec3::new(-1., -0.7, -0.4), Vec3::new(0., 0., 1.)).unwrap();
+ let defs = [def];
+ let scene = [identity(0, [0.; 3]), identity(0, [5., 0., 0.])];
+ assert!(matches!(hidden_lines(&defs, &scene, &view, &Options::default(), &|| true), Err(HlrError::Cancelled)));
+ assert!(matches!(hidden_lines(&defs, &scene, &view, &Options { max_rays: 3, ..Options::default() }, &never), Err(HlrError::Budget(_))));
+ assert!(matches!(hidden_lines(&defs, &scene, &view, &Options { max_tracks: 1, ..Options::default() }, &never), Err(HlrError::Budget(_))));
+}
+
+#[test]
+fn two_touching_boxes_draw_each_shared_edge_once() {
+ let a = prepare(&cuboid([0.; 3], [10.; 3]), &Options::default()).unwrap();
+ let b = prepare(&cuboid([10., 0., 0.], [20., 10., 10.]), &Options::default()).unwrap();
+ let view = View::new(Vec3::new(-1., -0.7, -0.5), Vec3::new(0., 0., 1.)).unwrap();
+ let d = hidden_lines(&[a, b], &[identity(0, [0.; 3]), identity(1, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ assert_eq!(d.stats.uncertain_uncovered, 0, "{:?}", d.stats);
+ // The edges at x = 10: 5, 7, 9, 11 of the first box are 4, 6, 8, 10 of the second.
+ let uncovered = |l: &Line| -> f64 { l.pieces.iter().filter(|p| !p.covered).map(|p| p.t[1] - p.t[0]).sum() };
+ for (ea, eb) in [(5, 4), (7, 6), (9, 8), (11, 10)] {
+ let once = uncovered(edge_line(&d, 0, ea)) + uncovered(edge_line(&d, 1, eb));
+ assert!((once - 1.).abs() < 1e-9, "edges {ea}/{eb} drawn {once} times");
+ }
+}
+
+#[test]
+fn a_cone_in_a_front_view_has_exact_outline_rulings_and_edge_on_circles() {
+ // A frustum from radius 5 at z = 0 to 10 at z = 20, seen exactly from the front: the
+ // rulings run from (+-5, 0) to (+-10, 20) (one along the seam) and each circle is drawn
+ // once as the segment it is seen edge-on as.
+ let def = prepare(&turned(5., 10., 20.), &Options::default()).unwrap();
+ let view = View::new(Vec3::new(0., 1., 0.), Vec3::new(0., 0., 1.)).unwrap();
+ let d = hidden_lines(&[def], &[identity(0, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ assert_eq!(d.stats.uncertain_uncovered, 0, "{:?}", d.stats);
+ let mut rulings: Vec<[f64; 4]> = Vec::new();
+ for p in silhouette_pieces(&d) {
+ assert_eq!((p.visibility, p.accuracy), (Visibility::Visible, CurveAccuracy::Analytic));
+ for g in &p.geometry {
+ let Seg2::Line { a, b } = *g else { panic!("a ruling is a line: {g:?}") };
+ let (a, b) = if a.y <= b.y { (a, b) } else { (b, a) };
+ rulings.push([a.x, a.y, b.x, b.y]);
+ }
+ }
+ rulings.sort_by(|a, b| a[0].total_cmp(&b[0]));
+ assert_eq!(rulings.len(), 2, "{rulings:?}");
+ for (r, want) in rulings.iter().zip([[-5., 0., -10., 20.], [5., 0., 10., 20.]]) {
+ assert!(r.iter().zip(want).all(|(x, y)| (x - y).abs() < 1e-9), "{rulings:?}");
+ }
+ for (edge, (y, half)) in [(0, (0., 5.)), (1, (20., 10.))] {
+ let drawn: f64 = edge_line(&d, 0, edge)
+ .pieces
+ .iter()
+ .filter(|p| p.visibility == Visibility::Visible && !p.covered)
+ .flat_map(|p| p.geometry.iter())
+ .map(|g| {
+ let (a, b) = (g.point_at(0.), g.point_at(1.));
+ assert!((a.y - y).abs() < 1e-9 && (b.y - y).abs() < 1e-9 && a.x.abs() <= half + 1e-9, "{g:?}");
+ (b.x - a.x).abs()
+ })
+ .sum();
+ assert!((drawn - 2. * half).abs() < 1e-6, "circle {edge}: {drawn} mm drawn");
+ }
+}
+
+#[test]
+fn a_torus_seen_obliquely_spans_its_outer_diameter() {
+ // Across the view (screen x is square to the axis here) the outline of a torus reaches
+ // R + r on both sides, whatever the tilt; the traced silhouette reports its deviation.
+ let def = prepare(&torus(20., 5.), &Options::default()).unwrap();
+ for tilt in [0.3, 1., 3.] {
+ let view = View::new(Vec3::new(0., 1., -tilt), Vec3::new(0., 0., 1.)).unwrap();
+ let d = hidden_lines(std::slice::from_ref(&def), &[identity(0, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ assert_eq!(d.stats.uncertain_uncovered, 0, "tilt {tilt}: {:?}", d.stats);
+ let mut dev = 0f64;
+ let (mut lo, mut hi) = (f64::MAX, f64::MIN);
+ for p in pieces(&d).filter(|p| p.visibility == Visibility::Visible && !p.covered) {
+ if let CurveAccuracy::Sampled { max_sample_deviation_mm } = p.accuracy {
+ dev = dev.max(max_sample_deviation_mm);
+ }
+ for g in &p.geometry {
+ for s in [0., 0.5, 1.] {
+ let q = g.point_at(s);
+ (lo, hi) = (lo.min(q.x), hi.max(q.x));
+ }
+ }
+ }
+ assert!(dev < 1e-3, "tilt {tilt}: deviation {dev}");
+ assert!((hi - 25.).abs() < 1e-3 && (lo + 25.).abs() < 1e-3, "tilt {tilt}: x from {lo} to {hi}");
+ }
+}
+
+/// A disc bounded by a rational quadratic circle of radius `r` (control points `pts` with
+/// weights 1 and 1/sqrt 2 alternating) whose first three quarters are squeezed into the
+/// parameters 0 to 0.009.
+fn squeezed_disc(r: f64, pts: [[f64; 2]; 9]) -> Brep {
+ disc(r, pts, vec![0., 0., 0., 0.003, 0.003, 0.006, 0.006, 0.009, 0.009, 1., 1., 1.])
+}
+
+/// A disc bounded by a rational quadratic spline with control points `pts` (weights 1 and
+/// 1/sqrt 2 alternating) and `knots`, starting at (`r`, 0).
+fn disc(r: f64, pts: [[f64; 2]; 9], knots: Vec<f64>) -> Brep {
+ let s = std::f64::consts::FRAC_1_SQRT_2;
+ let homogeneous = pts.iter().enumerate().map(|(i, p)| if i % 2 == 1 { [p[0] * s, p[1] * s, 0., s] } else { [p[0], p[1], 0., 1.] }).collect();
+ Brep {
+ version: crate::brep::VERSION,
+ shells: vec![Shell {
+ vertices: vec![[r, 0., 0.]],
+ edges: vec![Edge { vertices: [0, 0], curve: Curve::RationalSpline { knots, homogeneous } }],
+ faces: vec![Face {
+ loops: vec![vec![uses(0, true)]],
+ surface: Surface::Plane { origin: [0.; 3], u_axis: [1., 0., 0.], v_axis: [0., 1., 0.] },
+ forward: true,
+ }],
+ }],
+ }
+}
+
+fn circle_points(r: f64) -> [[f64; 2]; 9] {
+ [[r, 0.], [r, r], [0., r], [-r, r], [-r, 0.], [-r, -r], [0., -r], [r, -r], [r, 0.]]
+}
+
+#[test]
+fn a_bent_quarter_in_a_knot_span_narrower_than_rounding_is_drawn() {
+ // The second quarter lives in the knot span 0.25 to 0.25 + 2^-50 and bulges to a radius of
+ // about 10.3: the edge is not taken for a circle and the bulge is drawn.
+ let mut pts = circle_points(10.);
+ if let Some(p) = pts.get_mut(3) {
+ *p = [-11., 10.];
+ }
+ let k = 0.25 + 2f64.powi(-50);
+ let def = prepare(&disc(10., pts, vec![0., 0., 0., 0.25, 0.25, k, k, 0.5, 0.5, 1., 1., 1.]), &Options::default()).unwrap();
+ let view = View::new(Vec3::new(0., 0., -1.), Vec3::new(0., 1., 0.)).unwrap();
+ let d = hidden_lines(&[def], &[identity(0, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ assert!(pieces(&d).all(|p| matches!(p.accuracy, CurveAccuracy::Sampled { .. })), "{d:?}");
+ let far = pieces(&d).flat_map(|p| p.geometry.iter()).flat_map(|g| [g.point_at(0.), g.point_at(1.)]).map(|q| q.len()).fold(0., f64::max);
+ assert!(far > 10.25, "the bulge reaches {far}");
+}
+
+#[test]
+fn an_unevenly_parameterised_circle_is_drawn_whole() {
+ // The conic arcs must still turn the full 360 degrees.
+ let def = prepare(&squeezed_disc(10., circle_points(10.)), &Options::default()).unwrap();
+ let view = View::new(Vec3::new(0.2, 0.1, -1.), Vec3::new(0., 1., 0.)).unwrap();
+ let d = hidden_lines(&[def], &[identity(0, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ let mut sweep = 0.;
+ for p in pieces(&d) {
+ assert_eq!((p.visibility, p.accuracy), (Visibility::Visible, CurveAccuracy::Analytic));
+ for g in &p.geometry {
+ let Seg2::Conic { w, .. } = *g else { panic!("a circle is drawn as conic arcs: {g:?}") };
+ sweep += 2. * w.acos();
+ }
+ }
+ assert!((sweep - std::f64::consts::TAU).abs() < 1e-9, "the arcs turn {sweep} rad");
+}
+
+#[test]
+fn a_spline_off_its_circle_in_a_narrow_knot_span_is_not_taken_for_one() {
+ // Moving one control point of the squeezed circle bends the span 0.003 to 0.006 off the
+ // circle by about 0.3 mm: the edge is drawn as sampled chords, not exact arcs.
+ let mut pts = circle_points(10.);
+ if let Some(p) = pts.get_mut(3) {
+ *p = [-11., 10.];
+ }
+ let def = prepare(&squeezed_disc(10., pts), &Options::default()).unwrap();
+ let view = View::new(Vec3::new(0.2, 0.1, -1.), Vec3::new(0., 1., 0.)).unwrap();
+ let d = hidden_lines(&[def], &[identity(0, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ assert!(pieces(&d).all(|p| matches!(p.accuracy, CurveAccuracy::Sampled { .. })), "{d:?}");
+}
+
+/// A cone frustum about a vertical axis through `o`: radius `r0` at the frame's origin and
+/// slope `k`, between the heights `h`.
+fn frustum(o: [f64; 3], r0: f64, k: f64, h: [f64; 2]) -> Shell {
+ let tau = std::f64::consts::TAU;
+ let at = |z: f64| [o[0] + r0 + k * z, o[1], o[2] + z];
+ let ring = |z: f64, v: u32| circle([o[0], o[1], o[2] + z], r0 + k * z, v);
+ let edges = vec![ring(h[0], 0), ring(h[1], 1), Edge { vertices: [0, 1], curve: Curve::Line { start: at(h[0]), end: at(h[1]) } }];
+ let plane = |z: f64, flip: f64| Surface::Plane { origin: [o[0], o[1], o[2] + z], u_axis: [1., 0., 0.], v_axis: [0., flip, 0.] };
+ let faces = vec![
+ Face {
+ loops: vec![vec![uses(0, true), uses(2, true), uses(1, false), uses(2, false)]],
+ surface: Surface::Cone { frame: frame_at(o), radius_at_origin: r0, half_angle: k.atan(), angle: [0., tau], height: h },
+ forward: true,
+ },
+ Face { loops: vec![vec![uses(0, false)]], surface: plane(h[0], -1.), forward: true },
+ Face { loops: vec![vec![uses(1, true)]], surface: plane(h[1], 1.), forward: true },
+ ];
+ Shell { vertices: vec![at(h[0]), at(h[1])], edges, faces }
+}
+
+#[test]
+fn nearly_coaxial_cones_far_out_keep_their_own_silhouettes() {
+ // Two frusta of slope 0.25 whose axes are slightly apart, far out: recognition may take
+ // them for one cone, but each is drawn with its own outline. Small ones 0.005 mm apart
+ // 1e7 mm out, and 1 km ones 0.4 mm apart 1e9 mm out.
+ for (x, r, gap) in [(1e7, 5., 0.005), (1e9, 1e6, 0.4)] {
+ let shells = vec![frustum([x, 0., 0.], r, 0.25, [0., 10.]), frustum([x + gap, 0., 0.], r, 0.25, [20., 30.])];
+ check_two_cone_outlines(&Brep { version: crate::brep::VERSION, shells });
+ }
+}
+
+/// A sector `a` (radians) of a cone about a vertical axis through `o`, radius `r0` at the
+/// frame's origin and slope `k`, between the heights `h`: one face, no caps.
+fn cone_sector(o: [f64; 3], r0: f64, k: f64, h: [f64; 2], a: [f64; 2]) -> Shell {
+ let at = |z: f64, t: f64| [o[0] + (r0 + k * z) * t.cos(), o[1] + (r0 + k * z) * t.sin(), o[2] + z];
+ let arc = |z: f64, v: u32, w: u32| Edge {
+ vertices: [v, w],
+ curve: Curve::CircleArc { frame: frame_at([o[0], o[1], o[2] + z]), radius: r0 + k * z, angle: a },
+ };
+ let ruling = |t: f64, v: u32, w: u32| Edge { vertices: [v, w], curve: Curve::Line { start: at(h[0], t), end: at(h[1], t) } };
+ let edges = vec![arc(h[0], 0, 1), ruling(a[1], 1, 2), arc(h[1], 3, 2), ruling(a[0], 0, 3)];
+ let face = Face {
+ loops: vec![vec![uses(0, true), uses(1, true), uses(2, false), uses(3, false)]],
+ surface: Surface::Cone { frame: frame_at(o), radius_at_origin: r0, half_angle: k.atan(), angle: a, height: h },
+ forward: true,
+ };
+ Shell { vertices: vec![at(h[0], a[0]), at(h[0], a[1]), at(h[1], a[1]), at(h[1], a[0])], edges, faces: vec![face] }
+}
+
+#[test]
+fn nearly_coincident_cone_sectors_both_draw_their_outline() {
+ // Two sectors (0 to 0.02 rad) of 1 m cones of slope 0.25, 1e9 mm out, axes 3e-6 mm apart,
+ // seen along the tangent at 0.01 rad: recognition takes them for one cone, but a ray along
+ // one's ruling would cross the other, so each keeps its own outline, visible over its
+ // whole height.
+ let x = 1e9;
+ let shells = vec![
+ cone_sector([x, 0., 0.], 1000., 0.25, [0., 1000.], [0., 0.02]),
+ cone_sector([x + 3e-6, 0., 0.], 1000., 0.25, [2000., 3000.], [0., 0.02]),
+ ];
+ let def = prepare(&Brep { version: crate::brep::VERSION, shells }, &Options::default()).unwrap();
+ let view = View::new(Vec3::new(-(0.01f64.sin()), 0.01f64.cos(), 0.), Vec3::new(0., 0., 1.)).unwrap();
+ let d = hidden_lines(&[def], &[identity(0, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ for (z0, z1) in [(0., 1000.), (2000., 3000.)] {
+ let drawn: f64 = silhouette_pieces(&d)
+ .iter()
+ .filter(|p| p.visibility == Visibility::Visible && !p.covered)
+ .flat_map(|p| p.geometry.iter())
+ .map(|g| {
+ let (a, b) = (g.point_at(0.).y.clamp(z0, z1), g.point_at(1.).y.clamp(z0, z1));
+ (b - a).abs()
+ })
+ .sum();
+ assert!((drawn - (z1 - z0)).abs() < 1e-3, "z {z0}..{z1}: {drawn} mm of ruling drawn");
+ }
+}
+
+/// A spherical cap of radius `r` about `c`: the latitudes from `lat` up to the pole, bounded by
+/// one circle through the vertex `v` at longitude 0.
+fn cap(c: [f64; 3], r: f64, lat: f64, edge: Curve, v: [f64; 3]) -> Shell {
+ let (tau, half) = (std::f64::consts::TAU, std::f64::consts::FRAC_PI_2);
+ let face = Face {
+ loops: vec![vec![uses(0, true)]],
+ surface: Surface::Sphere { frame: frame_at(c), radius: r, longitude: [0., tau], latitude: [lat, half] },
+ forward: true,
+ };
+ Shell { vertices: vec![v], edges: vec![Edge { vertices: [0, 0], curve: edge }], faces: vec![face] }
+}
+
+#[test]
+fn spherical_caps_through_one_circle_keep_their_own_outlines() {
+ // Two caps of radius 1000 whose centres are 5e-7 mm apart along the axis, both bounded by
+ // the same circle: recognition takes them for one sphere, the boundary lies on both, but
+ // inside they differ, so each draws its own outline.
+ let (r, z): (f64, f64) = (1000., 600.);
+ let ring = (r * r - z * z).sqrt();
+ let edge = || Curve::CircleArc { frame: frame_at([0., 0., z]), radius: ring, angle: [0., std::f64::consts::TAU] };
+ let dz = 5e-7;
+ let lat = |zc: f64| ((z - zc) / r).asin();
+ let shells = vec![
+ cap([0.; 3], r, lat(0.), edge(), [ring, 0., z]),
+ cap([0., 0., dz], (ring * ring + (z - dz).powi(2)).sqrt(), lat(dz), edge(), [ring, 0., z]),
+ ];
+ let def = prepare(&Brep { version: crate::brep::VERSION, shells }, &Options::default()).unwrap();
+ let view = View::new(Vec3::new(0., 1., 0.), Vec3::new(0., 0., 1.)).unwrap();
+ let d = hidden_lines(&[def], &[identity(0, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ // Above the ring the outline is a half circle of about pi * 1000 * 0.41 mm on each side.
+ let drawn: f64 = silhouette_pieces(&d)
+ .iter()
+ .filter(|p| p.visibility == Visibility::Visible && !p.covered)
+ .flat_map(|p| p.geometry.iter())
+ .map(|g| (0..32).map(|k| g.point_at(k as f64 / 32.).dist(g.point_at((k + 1) as f64 / 32.))).sum::<f64>())
+ .sum();
+ let arc = 2. * r * (std::f64::consts::FRAC_PI_2 - (z / r).asin());
+ assert!(drawn > 0.99 * arc, "{drawn} mm of outline drawn of about {arc}");
+ assert_eq!(d.stats.uncertain_uncovered, 0, "{:?}", d.stats);
+}
+
+/// The lateral face of a cone with its apex at the origin, slope 0.25, between the heights
+/// `h`, its axis turned by `tilt` about Y from +Z.
+fn tilted_cone(tilt: f64, h: [f64; 2]) -> Shell {
+ let (x, y, z) = (Vec3::new(tilt.cos(), 0., -tilt.sin()), Vec3::new(0., 1., 0.), Vec3::new(tilt.sin(), 0., tilt.cos()));
+ let arr = |v: Vec3| [v.x, v.y, v.z];
+ let frame = |o: Vec3| crate::brep::Frame { origin: arr(o), x_axis: arr(x), y_axis: arr(y) };
+ let at = |hh: f64| x * (0.25 * hh) + z * hh;
+ let ring = |hh: f64, v: u32| Edge {
+ vertices: [v, v],
+ curve: Curve::CircleArc { frame: frame(z * hh), radius: 0.25 * hh, angle: [0., std::f64::consts::TAU] },
+ };
+ let seam = Edge { vertices: [0, 1], curve: Curve::Line { start: arr(at(h[0])), end: arr(at(h[1])) } };
+ let face = Face {
+ loops: vec![vec![uses(0, true), uses(2, true), uses(1, false), uses(2, false)]],
+ surface: Surface::Cone {
+ frame: frame(Vec3::new(0., 0., 0.)),
+ radius_at_origin: 0.,
+ half_angle: 0.25f64.atan(),
+ angle: [0., std::f64::consts::TAU],
+ height: h,
+ },
+ forward: true,
+ };
+ Shell { vertices: vec![arr(at(h[0])), arr(at(h[1]))], edges: vec![ring(h[0], 0), ring(h[1], 1), seam], faces: vec![face] }
+}
+
+#[test]
+fn cones_with_slightly_turned_axes_keep_their_own_outlines() {
+ // One apex, axes 3e-7 rad apart, heights 1000 to 3000 and 6000 to 8000: each frustum draws
+ // both rulings of its own outline.
+ let shells = vec![tilted_cone(0., [1000., 3000.]), tilted_cone(3e-7, [6000., 8000.])];
+ let def = prepare(&Brep { version: crate::brep::VERSION, shells }, &Options::default()).unwrap();
+ let view = View::new(Vec3::new(0., 1., 0.), Vec3::new(0., 0., 1.)).unwrap();
+ let d = hidden_lines(&[def], &[identity(0, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ for (z0, z1) in [(1000., 3000.), (6000., 8000.)] {
+ let drawn: f64 = silhouette_pieces(&d)
+ .iter()
+ .filter(|p| p.visibility == Visibility::Visible && !p.covered)
+ .flat_map(|p| p.geometry.iter())
+ .filter(|g| g.point_at(0.5).y > z0 && g.point_at(0.5).y < z1)
+ .map(|g| g.point_at(0.).dist(g.point_at(1.)))
+ .sum();
+ let ruling = (z1 - z0) * (1f64 + 0.0625).sqrt();
+ assert!((drawn - 2. * ruling).abs() < 1e-3 * ruling, "z {z0}..{z1}: {drawn} mm of rulings drawn, want {}", 2. * ruling);
+ }
+}
+
+#[test]
+fn a_high_degree_spline_through_points_of_a_circle_is_not_taken_for_one() {
+ // A closed degree-16 Bezier through 17 points of a circle of radius 10 at t = j / 16, at
+ // unevenly spaced angles: on the circle at every t = j / 16 (where a check with evenly
+ // spaced samples would look), off it between them, so it is drawn as chords.
+ let n = 16usize;
+ let ts: Vec<f64> = (0..=n).map(|j| j as f64 / n as f64).collect();
+ let binom = |k: usize| (0..k).fold(1f64, |acc, i| acc * (n - i) as f64 / (i + 1) as f64);
+ // Solve the Bernstein collocation system for x and y by Gaussian elimination.
+ let mut rows: Vec<Vec<f64>> = ts
+ .iter()
+ .enumerate()
+ .map(|(j, t)| {
+ let a = std::f64::consts::TAU * j as f64 / n as f64 + 0.2 * (std::f64::consts::TAU * 3. * j as f64 / n as f64).sin();
+ let mut row: Vec<f64> = (0..=n).map(|i| binom(i) * t.powi(i as i32) * (1. - t).powi((n - i) as i32)).collect();
+ row.extend([10. * a.cos(), 10. * a.sin()]);
+ row
+ })
+ .collect();
+ for col in 0..=n {
+ let pivot = (col..=n).max_by(|a, b| rows[*a][col].abs().total_cmp(&rows[*b][col].abs())).unwrap();
+ rows.swap(col, pivot);
+ for r in 0..=n {
+ if r != col {
+ let f = rows[r][col] / rows[col][col];
+ let src = rows[col].clone();
+ for (x, s) in rows[r].iter_mut().zip(src) {
+ *x -= f * s;
+ }
+ }
+ }
+ }
+ let points: Vec<[f64; 3]> = (0..=n).map(|i| [rows[i][n + 1] / rows[i][i], rows[i][n + 2] / rows[i][i], 0.]).collect();
+ let knots: Vec<f64> = std::iter::repeat_n(0., n + 1).chain(std::iter::repeat_n(1., n + 1)).collect();
+ let start = points[0];
+ let disc = Brep {
+ version: crate::brep::VERSION,
+ shells: vec![Shell {
+ vertices: vec![start],
+ edges: vec![Edge { vertices: [0, 0], curve: Curve::Spline { knots, points } }],
+ faces: vec![Face {
+ loops: vec![vec![uses(0, true)]],
+ surface: Surface::Plane { origin: [0.; 3], u_axis: [1., 0., 0.], v_axis: [0., 1., 0.] },
+ forward: true,
+ }],
+ }],
+ };
+ let def = prepare(&disc, &Options::default()).unwrap();
+ let view = View::new(Vec3::new(0.2, 0.1, -1.), Vec3::new(0., 1., 0.)).unwrap();
+ let d = hidden_lines(&[def], &[identity(0, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ assert!(pieces(&d).all(|p| matches!(p.accuracy, CurveAccuracy::Sampled { .. })), "{:?}", pieces(&d).map(|p| p.accuracy).collect::<Vec<_>>());
+}
+
+fn check_two_cone_outlines(body: &Brep) {
+ let def = prepare(body, &Options::default()).unwrap();
+ let view = View::new(Vec3::new(0., 1., 0.), Vec3::new(0., 0., 1.)).unwrap();
+ let d = hidden_lines(&[def], &[identity(0, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ for (z0, z1) in [(0., 10.), (20., 30.)] {
+ let rulings = silhouette_pieces(&d)
+ .iter()
+ .filter(|p| p.visibility == Visibility::Visible && !p.covered)
+ .flat_map(|p| p.geometry.iter())
+ .filter(|g| {
+ let (a, b) = (g.point_at(0.), g.point_at(1.));
+ (a.y.min(b.y) - z0).abs() < 1e-6 && (a.y.max(b.y) - z1).abs() < 1e-6
+ })
+ .count();
+ assert_eq!(rulings, 2, "z {z0}..{z1}: {:?}", silhouette_pieces(&d));
+ }
+}
+
+#[test]
+fn the_shadow_index_finds_each_nearby_box_once() {
+ // 40 000 boxes 1 mm wide every 20 mm: a query near one finds it and no far one.
+ let mut list = Vec::new();
+ for i in 0..200 {
+ for j in 0..200 {
+ let (x, y) = (20. * i as f64, 20. * j as f64);
+ list.push(Shadow { lo: [x, y], hi: [x + 1., y + 1.], near: 0. });
+ }
+ }
+ let index = ShadowIndex::new(list).unwrap();
+ let mut near = Vec::new();
+ index.query([400.5, 600.5], [400.6, 600.6], &mut near);
+ let faces: Vec<usize> = near
+ .iter()
+ .copied()
+ .filter(|k| index.list.get(*k).is_some_and(|sh| sh.lo[0] <= 400.6 && sh.hi[0] >= 400.5 && sh.lo[1] <= 600.6 && sh.hi[1] >= 600.5))
+ .collect();
+ assert_eq!(faces, vec![20 * 200 + 30]);
+ assert!(near.len() <= 9, "{} candidates", near.len());
+ index.query([-50., -50.], [-40., -40.], &mut near);
+ assert!(near.is_empty());
+}
+
+#[test]
+fn a_plane_through_three_points_draws_as_a_plane() {
+ // The box with every face stored as the plane through three of its points draws the same
+ // bits as the box with axis-stored planes.
+ let o = Options::default();
+ let mut through = cuboid([0.; 3], [1.; 3]);
+ for f in &mut through.shells[0].faces {
+ let Surface::Plane { origin, u_axis, v_axis } = f.surface else { panic!("a box face is a plane") };
+ let at = |a: [f64; 3]| [origin[0] + a[0], origin[1] + a[1], origin[2] + a[2]];
+ f.surface = Surface::PlaneThrough { origin, u_point: at(u_axis), v_point: at(v_axis) };
+ }
+ let view = View::new(Vec3::new(-1., -0.8, -0.6), Vec3::new(0., 0., 1.)).unwrap();
+ let draw = |b: &Brep| {
+ let mut d = hidden_lines(&[prepare(b, &o).unwrap()], &[identity(0, [0.; 3])], &view, &o, &never).unwrap();
+ d.stats.phase_ms = [0.; 4];
+ format!("{d:?}")
+ };
+ assert!(draw(&through) == draw(&cuboid([0.; 3], [1.; 3])));
+}
+
+#[test]
+fn procedural_and_placed_records_are_not_supported_yet() {
+ let o = Options::default();
+ // A cylinder side stored as a placed revolution of its seam line.
+ let mut placed = cylinder(4., 10.);
+ let profile = Box::new(Curve::Line { start: [4., 0., 0.], end: [4., 0., 10.] });
+ let matrix = [[1., 0., 0., 0.], [0., 1., 0., 0.], [0., 0., 1., 0.], [0., 0., 0., 1.]];
+ placed.shells[0].faces[0].surface = Surface::PlacedRevolution { profile, origin: [0.; 3], axis: [0., 0., 1.], matrix, forward: true };
+ assert!(matches!(prepare(&placed, &o), Err(HlrError::Unsupported("placed revolution surface"))));
+ // A box edge stored as the meeting of the planes y = 0 and z = 0, traced from a leader.
+ let mut traced = cuboid([0.; 3], [1.; 3]);
+ let y0 = Box::new(Surface::Plane { origin: [0.; 3], u_axis: [1., 0., 0.], v_axis: [0., 0., 1.] });
+ let z0 = Box::new(Surface::Plane { origin: [0.; 3], u_axis: [1., 0., 0.], v_axis: [0., 1., 0.] });
+ let leader = Box::new(Curve::Polyline { points: vec![[0.; 3], [1., 0., 0.]] });
+ traced.shells[0].edges[0].curve = Curve::SurfaceIntersection { surfaces: [y0, z0], leader, tolerance: 1e-6 };
+ assert!(matches!(prepare(&traced, &o), Err(HlrError::Unsupported("surface intersection curve"))));
+}
+
+/// The edges whose every piece is hidden, in a box drawn from the isometric view.
+fn hidden_box_edges(b: &Brep) -> Vec<usize> {
+ let def = prepare(b, &Options::default()).unwrap();
+ let view = View::new(Vec3::new(-1., -1., -1.), Vec3::new(0., 0., 1.)).unwrap();
+ let d = hidden_lines(&[def], &[identity(0, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ let mut hidden = Vec::new();
+ for l in &d.lines {
+ let Source::Edge { edge, .. } = l.source else { panic!("a box has no silhouettes") };
+ let states: Vec<_> = l.pieces.iter().map(|p| p.visibility).collect();
+ assert!(states.windows(2).all(|w| w[0] == w[1]), "edge {edge} is split: {states:?}");
+ if states[0] == Visibility::Hidden {
+ hidden.push(edge);
+ }
+ }
+ hidden.sort_unstable();
+ hidden
+}
+
+#[test]
+fn a_plane_record_off_its_edges_by_rounding_still_hides() {
+ // The top face's plane stands one rounding (a 1 mm cube) or 1e-11 (a 100 mm cube) above
+ // its edges. Its box must still let the rays from the back edges reach it.
+ for (size, off) in [(1., 2.2e-16), (100., 1e-11), (1., -2.2e-16)] {
+ let mut b = cuboid([0.; 3], [size; 3]);
+ let Surface::Plane { origin, .. } = &mut b.shells[0].faces[1].surface else { panic!("the top face is a plane") };
+ assert_eq!(origin[2], size);
+ origin[2] += off;
+ assert_ne!(origin[2], size, "the offset must change the record");
+ assert_eq!(hidden_box_edges(&b), vec![0, 4, 8], "size {size}, offset {off}");
+ }
+ // A 0.001 mm cube modelled 1e7 mm out, its top plane one step (1.9e-9 mm) above its edges:
+ // more than 1e-6 of the face, so the padding must also grow with the coordinates.
+ let (c, size) = (1e7, 0.001);
+ let mut b = cuboid([c; 3], [c + size; 3]);
+ let Surface::Plane { origin, .. } = &mut b.shells[0].faces[1].surface else { panic!("the top face is a plane") };
+ origin[2] = f64::from_bits(origin[2].to_bits() + 1);
+ assert!(origin[2] - (c + size) > 1e-9);
+ assert_eq!(hidden_box_edges(&b), vec![0, 4, 8], "a tiny cube far out");
+}
+
+/// A plate of `n` by `n` holes of radius `r` at `pitch`, `h` thick: the faces of `cuboid`, a
+/// circle per hole in the top and bottom faces, and a cylinder face (seam at angle 0) per hole.
+fn holed_plate(n: usize, pitch: f64, r: f64, h: f64) -> Brep {
+ let tau = std::f64::consts::TAU;
+ let size = n as f64 * pitch;
+ let mut b = cuboid([0.; 3], [size, size, h]);
+ let shell = &mut b.shells[0];
+ for i in 0..n {
+ for j in 0..n {
+ let (cx, cy) = ((i as f64 + 0.5) * pitch, (j as f64 + 0.5) * pitch);
+ let v = shell.vertices.len() as u32;
+ shell.vertices.push([cx + r, cy, 0.]);
+ shell.vertices.push([cx + r, cy, h]);
+ let e = shell.edges.len() as u32;
+ shell.edges.push(circle([cx, cy, 0.], r, v));
+ shell.edges.push(circle([cx, cy, h], r, v + 1));
+ shell.edges.push(Edge { vertices: [v, v + 1], curve: Curve::Line { start: [cx + r, cy, 0.], end: [cx + r, cy, h] } });
+ // Holes run clockwise seen from outside: the bottom face looks down, the top up.
+ shell.faces[0].loops.push(vec![uses(e, true)]);
+ shell.faces[1].loops.push(vec![uses(e + 1, false)]);
+ shell.faces.push(Face {
+ loops: vec![vec![uses(e, true), uses(e + 2, true), uses(e + 1, false), uses(e + 2, false)]],
+ surface: Surface::Cylinder { frame: frame_at([cx, cy, 0.]), radius: r, angle: [0., tau], height: [0., h] },
+ forward: false,
+ });
+ }
+ }
+ b
+}
+
+#[test]
+fn trim_samples_and_scene_extents_beyond_their_limits_are_refused() {
+ for trim_samples in [0, MAX_TRIM_SAMPLES + 1] {
+ assert!(matches!(prepare(&cuboid([0.; 3], [1.; 3]), &Options { trim_samples, ..Options::default() }), Err(HlrError::Invalid(_))));
+ }
+ // Placements far apart once made the scene's size infinite and every piece visible.
+ let def = prepare(&cuboid([0.; 3], [1.; 3]), &Options::default()).unwrap();
+ let view = View::new(Vec3::new(-1., -1., -1.), Vec3::new(0., 0., 1.)).unwrap();
+ let defs = [def];
+ for far in [1e200, 2e12, -2e12] {
+ let scene = [identity(0, [0.; 3]), identity(0, [far, 0., 0.])];
+ assert!(matches!(hidden_lines(&defs, &scene, &view, &Options::default(), &never), Err(HlrError::Invalid("scene extent"))), "{far}");
+ }
+ let scene = [identity(0, [0.; 3]), identity(0, [1e11, 0., 0.])];
+ assert!(hidden_lines(&defs, &scene, &view, &Options::default(), &never).is_ok());
+}
+
+#[test]
+fn surface_groups_match_comparing_every_pair_and_preparing_can_be_cancelled() {
+ // Many holes of one radius, one a hair larger, a torus and a sphere in halves.
+ let mut b = holed_plate(4, 10., 3., 2.);
+ let wider = holed_plate(1, 10., 3. * (1. + 5e-10), 2.);
+ for s in [wider.shells[0].clone(), torus(5., 1.5).shells[0].clone(), sphere(4.).shells[0].clone()] {
+ b.shells.push(s);
+ }
+ let def = prepare(&b, &Options::default()).unwrap();
+ for (i, f) in def.faces.iter().enumerate() {
+ let every: Vec<usize> =
+ def.faces.iter().enumerate().filter(|(j, g)| *j == i || same_analytic(&f.analytic, &g.analytic, 1e-9)).map(|(j, _)| j).collect();
+ assert_eq!(f.group, every, "face {i}");
+ }
+ // The wider hole joins the first hole (same axis); the torus and sphere halves pair up.
+ assert_eq!(def.faces.iter().filter(|f| f.group.len() == 2).count(), 6);
+ assert!(matches!(prepare_cancellable(&b, &Options::default(), &|| true), Err(HlrError::Cancelled)));
+}
+
+#[test]
+fn the_chord_grid_finds_what_a_scan_of_every_chord_finds() {
+ // The plate's top face: 16 circles and a square, thousands of chords.
+ let def = prepare(&holed_plate(4, 10., 3., 2.), &Options::default()).unwrap();
+ let trim = &def.faces[1].trim;
+ assert!(trim.chords.len() > 1000);
+ let (lo, hi) = (trim.lo, trim.hi);
+ let mut checked = [0usize; 2];
+ for i in 0..=60 {
+ for j in 0..=60 {
+ let p = Vec3::new(lo.x + (hi.x - lo.x) * i as f64 / 60., lo.y + (hi.y - lo.y) * j as f64 / 60., lo.z + 1e-9 * (i % 3) as f64);
+ for tol in [1e-12, 1e-6, 0.01, 0.3, 2., 50.] {
+ let scan = trim.chords.iter().any(|(a, b)| p.dist_to_segment(*a, *b) <= tol);
+ assert_eq!(trim.near(p, tol), scan, "point {p:?}, tol {tol}");
+ checked[usize::from(scan)] += 1;
+ }
+ }
+ }
+ assert!(checked[0] > 1000 && checked[1] > 1000, "{checked:?}");
+}
+
+#[test]
+fn every_hole_of_a_plate_hides_the_same_part_of_its_bottom_circle() {
+ let def = prepare(&holed_plate(4, 10., 3., 2.), &Options::default()).unwrap();
+ let view = View::new(Vec3::new(-1., -0.8, -0.6), Vec3::new(0., 0., 1.)).unwrap();
+ let d = hidden_lines(&[def], &[identity(0, [0.; 3])], &view, &Options::default(), &never).unwrap();
+ let hidden =
+ |e: usize| -> f64 { edge_line(&d, 0, e).pieces.iter().filter(|p| p.visibility == Visibility::Hidden).map(|p| p.t[1] - p.t[0]).sum() };
+ // Edges 12, 15, 18, ...: each hole's bottom circle (12 box edges first).
+ let first = hidden(12);
+ assert!(first > 0.1 && first < std::f64::consts::TAU - 0.1, "part of a bottom circle is hidden by the wall: {first}");
+ for k in 1..16 {
+ let e = 12 + 3 * k;
+ assert!((hidden(e) - first).abs() < 1e-6, "hole {k}: {} against {first}", hidden(e));
+ let top = edge_line(&d, 0, e + 1);
+ assert!(top.pieces.iter().all(|p| p.visibility == Visibility::Visible), "hole {k}'s top circle is in front: {:?}", top.pieces);
+ }
+}
+
+#[test]
+fn coaxial_cylinders_seen_along_their_axis_draw_one_circle() {
+ // Eight cylinders stacked along Z, seen from above: all sixteen circles fall on one; only
+ // the top one shows, the others are hidden or lie under it.
+ let def = prepare(&cylinder(4., 10.), &Options::default()).unwrap();
+ let scene: Vec<Placement> = (0..8).map(|k| identity(0, [0., 0., 15. * k as f64])).collect();
+ let view = View::new(Vec3::new(0., 0., -1.), Vec3::new(0., 1., 0.)).unwrap();
+ let d = hidden_lines(&[def], &scene, &view, &Options::default(), &never).unwrap();
+ assert_eq!(d.stats.uncertain_uncovered, 0, "{:?}", d.stats);
+ // The circles meet at every sample point they share; none of that is a crossing (only the
+ // seam's ends, where each curve stops, may count): 120 pairs once gave over 100 000.
+ assert!(d.stats.crossings <= 4 * 120, "{:?}", d.stats);
+ for l in &d.lines {
+ let top = l.placement == 7 && l.source == Source::Edge { edge: 1, tangent: false };
+ let shown: f64 = l.pieces.iter().filter(|p| p.visibility == Visibility::Visible && !p.covered).map(|p| p.t[1] - p.t[0]).sum();
+ if top {
+ assert!((shown - std::f64::consts::TAU).abs() < 1e-9, "the top circle shows whole: {:?}", l.pieces);
+ } else {
+ assert_eq!(shown, 0., "placement {} {:?}: {:?}", l.placement, l.source, l.pieces);
+ }
+ }
+}
+
+#[test]
+fn a_few_hundred_placements_draw_as_one() {
+ // 300 boxes apart on screen: each is drawn exactly as the first one is.
+ let def = prepare(&cuboid([0.; 3], [1.; 3]), &Options::default()).unwrap();
+ let scene: Vec<Placement> = (0..300).map(|k| identity(0, [4. * (k % 20) as f64, 4. * (k / 20) as f64, 0.])).collect();
+ let view = View::new(Vec3::new(0.3, 0.2, -1.), Vec3::new(0., 1., 0.)).unwrap();
+ let d = hidden_lines(&[def], &scene, &view, &Options::default(), &never).unwrap();
+ assert_eq!(d.lines.len(), 300 * 12);
+ let first: Vec<&Line> = d.lines.iter().filter(|l| l.placement == 0).collect();
+ assert!(first.iter().any(|l| l.pieces.iter().any(|p| p.visibility == Visibility::Hidden)), "a box hides some of its own edges");
+ for (k, chunk) in d.lines.chunks(12).enumerate() {
+ for (l, f) in chunk.iter().zip(&first) {
+ assert_eq!((l.placement, l.source), (k, f.source));
+ assert_eq!(l.pieces.len(), f.pieces.len(), "placement {k} {:?}", l.source);
+ for (p, q) in l.pieces.iter().zip(&f.pieces) {
+ assert_eq!((p.visibility, p.covered), (q.visibility, q.covered), "placement {k} {:?}", l.source);
+ assert!((p.t[0] - q.t[0]).abs() < 1e-9 && (p.t[1] - q.t[1]).abs() < 1e-9, "placement {k} {:?}", l.source);
+ }
+ }
+ }
+}
+
+#[test]
+fn chords_only_near_each_other_still_meet_their_crossings() {
+ // An arc of radius 1000 sampled as one chord (sag about 5 mm) and a line 1 mm off that chord
+ // toward the arc's bulge: all four ends lie within the sag of the other chord, yet the arc
+ // crosses the line twice. The crossings must be found, not skipped as a coincidence.
+ let def = prepare(&cuboid([0.; 3], [1.; 3]), &Options::default()).unwrap();
+ let scene = [identity(0, [0.; 3])];
+ let view = View::new(Vec3::new(0., 0., -1.), Vec3::new(0., 1., 0.)).unwrap();
+ let defs = [def];
+ let ctx = context(&defs, &scene, &view, &Options::default(), &never).unwrap();
+ let arc = C3::Arc { o: Vec3::ZERO, x: Vec3::new(1., 0., 0.), y: Vec3::new(0., 1., 0.), r: [1000., 1000.], range: [0., 0.2] };
+ let (a, b) = (arc.at(0.), arc.at(0.2));
+ let sag = 1000. * (1. - 0.1f64.cos());
+ let out = Vec3::new(0.1f64.cos(), 0.1f64.sin(), 0.);
+ let line = C3::Line { a: a + out, b: b + out };
+ let track = |curve: &C3, range: [f64; 2], sag: f64| {
+ let screen = |t: f64| view.screen(curve.at(t));
+ Track {
+ placement: 0,
+ curve: TrackCurve::Owned(curve.clone()),
+ range,
+ source: Source::Edge { edge: 0, tangent: false },
+ acc: CurveAccuracy::Analytic,
+ own: Vec::new(),
+ own_eps: 1e-6,
+ samples: vec![(range[0], screen(range[0])), (range[1], screen(range[1]))],
+ sags: vec![sag],
+ splits: Vec::new(),
+ }
+ };
+ let mut tracks = vec![track(&arc, [0., 0.2], sag), track(&line, [0., 1.], 0.)];
+ assert!(sag > 4.9 && ((a + out).dist(a) - 1.).abs() < 1e-12);
+ assert_eq!(crossings(&mut tracks, &ctx).unwrap(), 2);
+ assert!(tracks.iter().all(|t| t.splits.len() == 2), "{:?}", tracks.iter().map(|t| &t.splits).collect::<Vec<_>>());
+}
diff --git a/crates/geom/src/lib.rs b/crates/geom/src/lib.rs
index 19a8f77a0c..0c60fbe722 100644
--- a/crates/geom/src/lib.rs
+++ b/crates/geom/src/lib.rs
@@ -15,21 +15,27 @@ pub mod blend;
pub mod brep;
pub mod bspline;
mod bvh;
+pub mod cell;
mod chain;
pub mod compare;
+pub mod drawing_sheet;
+pub mod drawing_view;
pub mod env;
pub mod fill;
pub mod fill_general;
mod grid;
+pub mod hlr;
mod mesh;
pub mod mesh_distance;
pub mod network;
+pub mod paper;
mod plane;
mod profile;
pub mod section;
pub mod simplify;
pub mod spline_space;
pub mod tess;
+pub mod title_block;
pub mod tspline;
mod unit_vec3;
mod vec;
@@ -42,7 +48,7 @@ pub use chain::{Chain, Closed, Ends, Open, Path, Planar, Ring};
pub use grid::Grid;
pub use mesh::{Aabb3, BoxedTriangle, InsideIndex, MassProperties, Mesh, MeshMeasure, find_close_pair};
pub use plane::Plane;
-pub use profile::{Loop2, MAX_BEZIER_CTRL, MAX_BEZIER_DEGREE, MAX_DERIVATIVE_ORDER, Region2, Seg2, bezier, regions_apart};
+pub use profile::{Loop2, MAX_BEZIER_CTRL, MAX_BEZIER_DEGREE, MAX_DERIVATIVE_ORDER, Region2, Seg2, Similarity2, bezier, regions_apart};
pub use unit_vec3::UnitVec3;
pub use vec::{Vec2, Vec3};
diff --git a/crates/geom/src/paper.rs b/crates/geom/src/paper.rs
new file mode 100644
index 0000000000..bcafed7796
--- /dev/null
+++ b/crates/geom/src/paper.rs
@@ -0,0 +1,222 @@
+//! The paper scene: what a sheet shows, as strokes and fills in sheet millimetres, for the writers
+//! that put it in a file (DXF, SVG, PNG, PDF). Plain data with one check, [`Scene::validate`]:
+//! nothing here is saved, drawn on screen or made by a command yet. Text, clips, line patterns and
+//! styles are later additions.
+//!
+//! - Coordinates are millimetres from the sheet's lower-left corner, x to the right and y up;
+//! angles are radians, anticlockwise. A line's width is its width on paper, centred on its path.
+//! - Paint goes on in order: the groups in turn, then the items of each group in turn, each over
+//! what is already there.
+//! - A stroke has butt caps and miter joins with a miter limit of 4 (a join sharper than about 29°
+//! is bevelled). A closed stroke joins at its start instead of having two caps. A fill is
+//! painted even-odd, so a hole is a hole whichever way its loop runs.
+//! - Each group says which object on the sheet drew it, by an id, and what kind of object that is.
+//! The id is opaque here: it names one object within the sheet, and several groups may come from
+//! the same object. DXF and PDF put a group on the layer its kind names ([`ObjectKind::layer`]).
+//!
+//! [`Scene::validate`] checks a scene before any writer reads it:
+//! - at most [`MAX_RECORDS`] groups, items, loops and curve pieces in all, counted before any
+//! geometry is read;
+//! - each side of the sheet above 0 and at most [`MAX_SIDE_MM`];
+//! - each piece's numbers through the checks section geometry uses, with every stored coordinate
+//! and radius finite and at most 1e5 mm in size, so every point drawn has both coordinates
+//! within ±2e5 mm;
+//! - a stroke's pieces meeting end to start within [`EPS`], and its ends too when it is closed;
+//! every loop of a fill closed the same way;
+//! - a line width above 0 and at most [`MAX_LINE_MM`].
+//!
+//! It does not certify simple loops, holes inside their outer loop or a path that never doubles
+//! back. Validation after parsing cannot bound parsing allocations: an encoded-input boundary must
+//! also limit bytes and nesting.
+//!
+//! Writers read a [`Prepared`] scene, which only [`Scene::prepare`] makes, so none reads one that
+//! wasn't checked. Clipping will happen there too, once, before any writer (A8).
+
+use serde::{Deserialize, Serialize};
+
+use std::f64::consts::FRAC_PI_2;
+
+use crate::{EPS, Region2, Seg2, Vec2};
+
+/// The widest line a scene may draw, in millimetres.
+pub const MAX_LINE_MM: f64 = 10.0;
+/// The longest side a sheet may have, in millimetres.
+pub const MAX_SIDE_MM: f64 = 5000.0;
+/// Groups, items, loops and curve pieces a scene may hold in all.
+pub const MAX_RECORDS: usize = 100_000;
+/// The largest coordinate and radius either way, in millimetres: twenty times the longest side.
+pub const MAX_COORDINATE_MM: f64 = 1e5;
+
+/// One sheet's marks, in paint order.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct Scene {
+ /// The sheet's width and height.
+ pub size_mm: Vec2,
+ pub groups: Vec<Group>,
+}
+
+/// Items one object on the sheet drew, painted in order.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct Group {
+ /// The id of the object that drew these items, opaque here.
+ pub object: u64,
+ /// What kind of object it is.
+ pub kind: ObjectKind,
+ pub items: Vec<Item>,
+}
+
+/// What kind of object drew a group.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum ObjectKind {
+ /// The physical edge of the sheet's paper.
+ SheetBorder,
+ /// The outline inside the sheet border that bounds the views and annotations, with the grid
+ /// and the centring and trimming marks of its profile.
+ DrawingBorder,
+ /// The block of fields that identifies the drawing and what its sheet documents.
+ TitleBlock,
+ /// The sheet table that presents an assembly's bill of materials.
+ PartsList,
+ /// The sheet table that lists the drawing's revisions.
+ RevisionTable,
+}
+
+impl ObjectKind {
+ /// The layer DXF and PDF put this kind's groups on: its name in capitals, as DXF layers are
+ /// named.
+ pub fn layer(self) -> &'static str {
+ match self {
+ ObjectKind::SheetBorder => "SHEET_BORDER",
+ ObjectKind::DrawingBorder => "DRAWING_BORDER",
+ ObjectKind::TitleBlock => "TITLE_BLOCK",
+ ObjectKind::PartsList => "PARTS_LIST",
+ ObjectKind::RevisionTable => "REVISION_TABLE",
+ }
+ }
+}
+
+/// One mark on the paper.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
+pub enum Item {
+ /// A line `width_mm` wide along `path`, each piece starting where the one before ends. A
+ /// closed stroke also ends where it starts.
+ Stroke { path: Vec<Seg2>, closed: bool, width_mm: f64 },
+ /// A region painted solid.
+ Fill { region: Region2 },
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
+#[error("paper scene: {0}")]
+pub struct Invalid(pub &'static str);
+
+type Result<T> = std::result::Result<T, Invalid>;
+
+fn require(condition: bool, message: &'static str) -> Result<()> {
+ if condition { Ok(()) } else { Err(Invalid(message)) }
+}
+
+struct Budget(usize);
+impl Budget {
+ fn add(&mut self, n: usize) -> Result<()> {
+ const MESSAGE: &str = "more than 100,000 groups, items, loops and pieces";
+ self.0 = self.0.checked_add(n).ok_or(Invalid(MESSAGE))?;
+ require(self.0 <= MAX_RECORDS, MESSAGE)
+ }
+}
+
+fn pieces(segs: &[Seg2]) -> Result<()> {
+ segs.iter().try_for_each(|s| s.check(MAX_COORDINATE_MM).map_err(Invalid))
+}
+
+/// Whether `b` starts where `a` ends.
+fn meet(a: &Seg2, b: &Seg2) -> bool {
+ a.end().dist(b.start()) <= EPS
+}
+
+/// A scene that passed [`Scene::validate`]: what every writer reads.
+#[derive(Clone, Copy, Debug)]
+pub struct Prepared<'a> {
+ scene: &'a Scene,
+}
+
+impl<'a> Prepared<'a> {
+ pub fn size_mm(&self) -> Vec2 {
+ self.scene.size_mm
+ }
+
+ /// The groups, in paint order.
+ pub fn groups(&self) -> &'a [Group] {
+ &self.scene.groups
+ }
+}
+
+/// The ends of the pieces of at most a quarter turn the arc of `sweep` radians from `start`
+/// round `center` is drawn in, in order, the last its own end. For writers that draw an arc from
+/// its ends (SVG's `A`): there a half turn's centre is ill-conditioned, and moves by up to 1e-2 mm
+/// once its ends are rounded to the nanometre (six decimals of a millimetre), where a quarter
+/// turn's stays under 1e-6 mm.
+pub fn arc_pieces(center: Vec2, radius: f64, start: f64, sweep: f64) -> impl Iterator<Item = Vec2> {
+ // A scene's sweeps are at most a whole turn and a little: one to four pieces.
+ let n = ((sweep.abs() / FRAC_PI_2) - 1e-9).ceil().clamp(1.0, 4.0) as usize;
+ (1..=n).map(move |k| {
+ let angle = if k == n { start + sweep } else { start + sweep * (k as f64 / n as f64) };
+ center + Vec2::from_angle(angle) * radius
+ })
+}
+
+impl Scene {
+ /// The scene, checked ([`Scene::validate`]), for the writers.
+ pub fn prepare(&self) -> Result<Prepared<'_>> {
+ self.validate()?;
+ Ok(Prepared { scene: self })
+ }
+
+ /// Checks the scene against the limits in the module's notes, counting its records first.
+ pub fn validate(&self) -> Result<()> {
+ let mut budget = Budget(0);
+ budget.add(self.groups.len())?;
+ for group in &self.groups {
+ budget.add(group.items.len())?;
+ for item in &group.items {
+ match item {
+ Item::Stroke { path, .. } => budget.add(path.len())?,
+ Item::Fill { region } => {
+ for l in region.loops() {
+ budget.add(1 + l.segs.len())?;
+ }
+ }
+ }
+ }
+ }
+ let Vec2 { x, y } = self.size_mm;
+ require([x, y].into_iter().all(|side| side > 0.0 && side <= MAX_SIDE_MM), "each side of the sheet is above 0 and at most 5000 mm")?;
+ for item in self.groups.iter().flat_map(|g| &g.items) {
+ match item {
+ Item::Stroke { path, closed, width_mm } => {
+ require(*width_mm > 0.0 && *width_mm <= MAX_LINE_MM, "a line is above 0 and at most 10 mm wide")?;
+ require(!path.is_empty(), "a stroke has at least one piece")?;
+ pieces(path)?;
+ require(path.iter().zip(path.iter().skip(1)).all(|(a, b)| meet(a, b)), "a stroke's pieces meet end to start")?;
+ if *closed {
+ require(path.last().zip(path.first()).is_some_and(|(a, b)| meet(a, b)), "a closed stroke ends where it starts")?;
+ }
+ }
+ Item::Fill { region } => {
+ for l in region.loops() {
+ pieces(&l.segs)?;
+ require(l.is_closed(EPS), "each loop of a fill is closed")?;
+ }
+ }
+ }
+ }
+ Ok(())
+ }
+}
+
+#[cfg(test)]
+#[path = "paper_tests.rs"]
+mod tests;
diff --git a/crates/geom/src/paper_tests.rs b/crates/geom/src/paper_tests.rs
new file mode 100644
index 0000000000..8cc36a6e55
--- /dev/null
+++ b/crates/geom/src/paper_tests.rs
@@ -0,0 +1,305 @@
+use std::f64::consts::{PI, TAU};
+
+use serde_json::json;
+
+use super::*;
+use crate::{Loop2, MAX_BEZIER_CTRL};
+
+fn p(x: f64, y: f64) -> Vec2 {
+ Vec2::new(x, y)
+}
+
+fn line(a: Vec2, b: Vec2) -> Seg2 {
+ Seg2::Line { a, b }
+}
+
+fn stroke(path: Vec<Seg2>, closed: bool, width_mm: f64) -> Item {
+ Item::Stroke { path, closed, width_mm }
+}
+
+fn fill(outer: Loop2, holes: Vec<Loop2>) -> Item {
+ Item::Fill { region: Region2 { outer, holes } }
+}
+
+/// Anticlockwise from `min`.
+fn rectangle(min: Vec2, max: Vec2) -> Loop2 {
+ Loop2::polygon(&[min, p(max.x, min.y), max, p(min.x, max.y)])
+}
+
+/// An A3 landscape sheet with one object's items.
+fn sheet(items: Vec<Item>) -> Scene {
+ Scene { size_mm: p(420.0, 297.0), groups: vec![Group { object: 1, kind: ObjectKind::DrawingBorder, items }] }
+}
+
+fn open(path: Vec<Seg2>) -> Scene {
+ sheet(vec![stroke(path, false, 0.35)])
+}
+
+fn closed(path: Vec<Seg2>) -> Scene {
+ sheet(vec![stroke(path, true, 0.35)])
+}
+
+/// ISO 5457's drawing border on an A3 landscape sheet, and the two trimming rectangles at its
+/// lower-left corner, by hand.
+fn a3() -> Scene {
+ sheet(vec![
+ stroke(rectangle(p(20.0, 10.0), p(410.0, 287.0)).segs, true, 0.7),
+ fill(rectangle(p(0.0, 0.0), p(10.0, 5.0)), vec![]),
+ fill(rectangle(p(0.0, 0.0), p(5.0, 10.0)), vec![]),
+ ])
+}
+
+#[test]
+fn an_a3_drawing_border_and_its_trimming_marks_validate_and_round_trip() {
+ let scene = a3();
+ scene.validate().unwrap();
+ let value = serde_json::to_value(&scene).unwrap();
+ assert_eq!(value["size_mm"], json!([420.0, 297.0]));
+ let group = &value["groups"][0];
+ assert_eq!(group["object"], json!(1));
+ assert_eq!(group["kind"], "drawing_border");
+ let border = &group["items"][0];
+ assert_eq!(border["kind"], "stroke");
+ assert_eq!(border["closed"], true);
+ assert_eq!(border["width_mm"], 0.7);
+ assert_eq!(border["path"][0], json!({"type": "line", "a": [20.0, 10.0], "b": [410.0, 10.0]}));
+ assert_eq!(border["path"][2], json!({"type": "line", "a": [410.0, 287.0], "b": [20.0, 287.0]}));
+ assert_eq!(border["path"][3]["b"], json!([20.0, 10.0]));
+ let trim = &group["items"][2];
+ assert_eq!(trim["kind"], "fill");
+ assert_eq!(trim["region"]["outer"]["segs"][1], json!({"type": "line", "a": [5.0, 0.0], "b": [5.0, 10.0]}));
+ assert_eq!(trim["region"]["holes"], json!([]));
+ let restored: Scene = serde_json::from_value(value).unwrap();
+ restored.validate().unwrap();
+ assert_eq!(restored, scene);
+}
+
+#[test]
+fn each_kind_names_its_layer_in_the_capitals_of_its_id() {
+ use ObjectKind::*;
+ for (kind, layer) in [
+ (SheetBorder, "SHEET_BORDER"),
+ (DrawingBorder, "DRAWING_BORDER"),
+ (TitleBlock, "TITLE_BLOCK"),
+ (PartsList, "PARTS_LIST"),
+ (RevisionTable, "REVISION_TABLE"),
+ ] {
+ assert_eq!(kind.layer(), layer);
+ let id = layer.to_ascii_lowercase();
+ assert_eq!(serde_json::to_value(kind).unwrap(), json!(id));
+ assert_eq!(serde_json::from_value::<ObjectKind>(json!(id)).unwrap(), kind);
+ }
+}
+
+#[test]
+fn each_side_of_the_sheet_is_above_zero_and_at_most_5000_mm() {
+ const REFUSED: Invalid = Invalid("each side of the sheet is above 0 and at most 5000 mm");
+ // Marks may lie off a small sheet: the scene doesn't clip them.
+ for side in [5000.0, 1e-9, f64::MIN_POSITIVE] {
+ for size_mm in [p(side, 297.0), p(420.0, side)] {
+ Scene { size_mm, ..a3() }.validate().unwrap();
+ }
+ }
+ for side in [0.0, -0.0, -1.0, 5000.001, 5000f64.next_up(), f64::NAN, f64::INFINITY, f64::NEG_INFINITY] {
+ for size_mm in [p(side, 297.0), p(420.0, side)] {
+ assert_eq!(Scene { size_mm, ..a3() }.validate(), Err(REFUSED), "{size_mm:?}");
+ }
+ }
+}
+
+#[test]
+fn a_line_is_above_zero_and_at_most_10_mm_wide() {
+ let border = |width| sheet(vec![stroke(rectangle(p(20.0, 10.0), p(410.0, 287.0)).segs, true, width)]);
+ for width in [1e-9, 0.7, 10.0] {
+ border(width).validate().unwrap();
+ }
+ for width in [0.0, -0.0, -0.7, 10.000001, 10f64.next_up(), f64::NAN, f64::INFINITY] {
+ assert_eq!(border(width).validate(), Err(Invalid("a line is above 0 and at most 10 mm wide")), "{width}");
+ }
+}
+
+#[test]
+fn coordinates_and_radii_are_finite_and_at_most_1e5_mm() {
+ const REFUSED: Invalid = Invalid("non-finite or excessive coordinate");
+ for v in [1e5, -1e5] {
+ open(vec![line(p(0.0, 0.0), p(v, 0.0))]).validate().unwrap();
+ open(vec![line(p(0.0, v), p(1.0, 0.0))]).validate().unwrap();
+ }
+ for v in [1e5 + 1e-6, -1e5 - 1e-6, 1e5f64.next_up(), f64::NAN, f64::INFINITY, f64::NEG_INFINITY] {
+ assert_eq!(open(vec![line(p(0.0, 0.0), p(v, 0.0))]).validate(), Err(REFUSED), "{v}");
+ assert_eq!(open(vec![line(p(0.0, v), p(1.0, 0.0))]).validate(), Err(REFUSED), "{v}");
+ assert_eq!(sheet(vec![fill(rectangle(p(0.0, 0.0), p(v, 1.0)), vec![])]).validate(), Err(REFUSED), "{v}");
+ }
+ // A radius has the same bound, so a circle's points stay within ±2e5 mm each way.
+ let circle = |center, radius| vec![Seg2::Arc { center, radius, start: 0.0, sweep: TAU }];
+ closed(circle(p(1e5, -1e5), 1e5)).validate().unwrap();
+ for radius in [1e5 + 1e-6, 0.0, -1.0, 1e-13, f64::NAN, f64::INFINITY] {
+ assert_eq!(closed(circle(p(0.0, 0.0), radius)).validate(), Err(Invalid("arc radius")), "{radius}");
+ }
+ assert_eq!(closed(circle(p(1e5 + 1e-6, 0.0), 1.0)).validate(), Err(REFUSED));
+}
+
+#[test]
+fn every_piece_goes_through_the_section_checks_at_the_papers_bound() {
+ let arc = |radius, start, sweep| Seg2::Arc { center: p(50.0, 50.0), radius, start, sweep };
+ let conic = |w| Seg2::Conic { a: p(1.0, 0.0), apex: p(1.0, 1.0), b: p(0.0, 1.0), w };
+ let one = p(1.0, 1.0);
+ for (piece, message) in [
+ (arc(0.0, 0.0, PI), "arc radius"),
+ (arc(10.0, 1e6 + 1.0, PI), "arc start angle"),
+ (arc(10.0, 0.0, 0.0), "arc sweep"),
+ (arc(10.0, 0.0, -TAU - 1e-8), "arc sweep"),
+ (conic(0.0), "conic weight"),
+ (conic(1e12 + 1.0), "conic weight"),
+ (line(one, one), "collapsed curve"),
+ (Seg2::Cubic { p0: one, p1: one, p2: one, p3: one }, "collapsed curve"),
+ ] {
+ assert_eq!(open(vec![piece]).validate(), Err(Invalid(message)), "{piece:?}");
+ }
+ // A conic's weight is a ratio, not a length: the paper's bound doesn't apply to it.
+ open(vec![conic(1e12)]).validate().unwrap();
+ // A fill's loops go through the same checks: a zero-radius arc in a hole.
+ let hole = Loop2 { segs: vec![arc(0.0, 0.0, TAU)] };
+ assert_eq!(sheet(vec![fill(rectangle(p(0.0, 0.0), p(100.0, 100.0)), vec![hole])]).validate(), Err(Invalid("arc radius")));
+ // A Bézier's unused slots are checked at the paper's bound too, as they are serialized.
+ let mut controls = [Vec2::ZERO; MAX_BEZIER_CTRL];
+ for (i, q) in controls.iter_mut().enumerate().take(5) {
+ *q = p(i as f64, (i % 2) as f64);
+ }
+ open(vec![Seg2::Bezier { n: 4, p: controls }]).validate().unwrap();
+ for value in [f64::NAN, f64::INFINITY, 1e5 + 1e-6] {
+ let mut hidden = controls;
+ hidden[MAX_BEZIER_CTRL - 1] = p(value, 0.0);
+ assert_eq!(open(vec![Seg2::Bezier { n: 4, p: hidden }]).validate(), Err(Invalid("non-finite or excessive coordinate")), "{value}");
+ }
+ for n in [3, 10] {
+ assert_eq!(open(vec![Seg2::Bezier { n, p: controls }]).validate(), Err(Invalid("Bezier degree")));
+ }
+}
+
+#[test]
+fn a_strokes_pieces_meet_within_1e_9_mm_and_a_closed_one_ends_where_it_starts() {
+ const APART: Invalid = Invalid("a stroke's pieces meet end to start");
+ const OPEN_ENDS: Invalid = Invalid("a closed stroke ends where it starts");
+ // The joins lie at the origin, where a gap of 1e-9 mm is exact.
+ let corner = |gap| vec![line(p(-10.0, 0.0), p(0.0, 0.0)), line(p(gap, 0.0), p(0.0, 10.0))];
+ open(corner(1e-9)).validate().unwrap();
+ for gap in [2e-9, 1e-9f64.next_up(), -2e-9] {
+ assert_eq!(open(corner(gap)).validate(), Err(APART), "{gap}");
+ }
+ let square = |gap| vec![line(p(0.0, 0.0), p(10.0, 0.0)), line(p(10.0, 0.0), p(10.0, 10.0)), line(p(10.0, 10.0), p(0.0, gap))];
+ closed(square(1e-9)).validate().unwrap();
+ for gap in [2e-9, 1e-9f64.next_up(), 10.0] {
+ assert_eq!(closed(square(gap)).validate(), Err(OPEN_ENDS), "{gap}");
+ open(square(gap)).validate().unwrap();
+ }
+}
+
+#[test]
+fn stroke_shapes_one_piece_reversed_duplicated_and_doubled_back() {
+ let a = line(p(0.0, 0.0), p(10.0, 0.0));
+ let border = rectangle(p(20.0, 10.0), p(410.0, 287.0));
+ open(vec![a]).validate().unwrap();
+ assert_eq!(closed(vec![a]).validate(), Err(Invalid("a closed stroke ends where it starts")));
+ assert_eq!(open(vec![]).validate(), Err(Invalid("a stroke has at least one piece")));
+ assert_eq!(closed(vec![]).validate(), Err(Invalid("a stroke has at least one piece")));
+ // A whole circle as one piece, or as two halves.
+ closed(vec![Seg2::Arc { center: p(100.0, 100.0), radius: 5.0, start: 0.3, sweep: -TAU }]).validate().unwrap();
+ closed(Loop2::circle(p(100.0, 100.0), 5.0).segs).validate().unwrap();
+ closed(border.reversed().segs).validate().unwrap();
+ // A piece twice over doesn't join; out of order neither.
+ assert_eq!(open(vec![a, a]).validate(), Err(Invalid("a stroke's pieces meet end to start")));
+ let mut swapped = border.segs.clone();
+ swapped.swap(1, 2);
+ assert_eq!(closed(swapped).validate(), Err(Invalid("a stroke's pieces meet end to start")));
+ // Doubling back joins, so it is accepted: the scene doesn't certify a path.
+ open(vec![a, a.reversed()]).validate().unwrap();
+ closed(vec![a, a.reversed()]).validate().unwrap();
+ // Nothing to draw is a valid scene, and so is an object that drew nothing.
+ Scene { groups: vec![], ..a3() }.validate().unwrap();
+ sheet(vec![]).validate().unwrap();
+}
+
+#[test]
+fn every_loop_of_a_fill_is_closed_within_1e_9_mm() {
+ const OPEN: Invalid = Invalid("each loop of a fill is closed");
+ let outer = rectangle(p(0.0, 0.0), p(100.0, 100.0));
+ // A triangle whose last piece ends `gap` from its start, at the origin.
+ let triangle = |gap| Loop2 { segs: vec![line(p(0.0, 0.0), p(10.0, 0.0)), line(p(10.0, 0.0), p(0.0, 10.0)), line(p(0.0, 10.0), p(0.0, gap))] };
+ sheet(vec![fill(triangle(1e-9), vec![])]).validate().unwrap();
+ let hole = |gap: f64| triangle(gap).reversed();
+ sheet(vec![fill(outer.clone(), vec![hole(1e-9)])]).validate().unwrap();
+ for gap in [2e-9, 1e-9f64.next_up(), 5.0] {
+ assert_eq!(sheet(vec![fill(triangle(gap), vec![])]).validate(), Err(OPEN), "{gap}");
+ assert_eq!(sheet(vec![fill(outer.clone(), vec![hole(gap)])]).validate(), Err(OPEN), "{gap}");
+ }
+ assert_eq!(sheet(vec![fill(Loop2::default(), vec![])]).validate(), Err(OPEN));
+ assert_eq!(sheet(vec![fill(outer.clone(), vec![Loop2::default()])]).validate(), Err(OPEN));
+ // Even-odd: a hole that runs the same way as its outer loop, and a round hole, are accepted.
+ sheet(vec![fill(outer.clone(), vec![rectangle(p(10.0, 10.0), p(20.0, 20.0))])]).validate().unwrap();
+ sheet(vec![fill(outer, vec![Loop2::circle(p(50.0, 50.0), 5.0).reversed()])]).validate().unwrap();
+}
+
+#[test]
+fn at_most_100_000_records_are_counted_before_any_geometry() {
+ const REFUSED: Invalid = Invalid("more than 100,000 groups, items, loops and pieces");
+ let group = |items| Group { object: 7, kind: ObjectKind::PartsList, items };
+ let scene = |groups| Scene { size_mm: p(420.0, 297.0), groups };
+ // Groups alone.
+ scene(vec![group(vec![]); MAX_RECORDS]).validate().unwrap();
+ assert_eq!(scene(vec![group(vec![]); MAX_RECORDS + 1]).validate(), Err(REFUSED));
+ // One group and one stroke, then its pieces.
+ let steps = |n: usize| -> Vec<Seg2> { (0..n).map(|i| line(p(i as f64 * 1e-3, 0.0), p((i + 1) as f64 * 1e-3, 0.0))).collect() };
+ scene(vec![group(vec![stroke(steps(MAX_RECORDS - 2), false, 0.35)])]).validate().unwrap();
+ assert_eq!(scene(vec![group(vec![stroke(steps(MAX_RECORDS - 1), false, 0.35)])]).validate(), Err(REFUSED));
+ // A fill counts each loop as well as its pieces: 2 + (1 + 5) + 49,996 × (1 + 1) = 100,000.
+ let holes = vec![Loop2 { segs: vec![Seg2::Arc { center: p(200.0, 150.0), radius: 1.0, start: 0.0, sweep: TAU }] }; 49_996];
+ let polygon = |n: usize| {
+ let corners: Vec<Vec2> = (0..n).map(|i| p(200.0, 150.0) + Vec2::from_angle(TAU * i as f64 / n as f64) * 100.0).collect();
+ Loop2::polygon(&corners)
+ };
+ scene(vec![group(vec![fill(polygon(5), holes.clone())])]).validate().unwrap();
+ assert_eq!(scene(vec![group(vec![fill(polygon(6), holes)])]).validate(), Err(REFUSED));
+ // Counted first: an over-budget scene with a non-finite piece reports the count.
+ let mut bad = steps(MAX_RECORDS - 1);
+ bad[0] = line(p(f64::NAN, 0.0), p(1.0, 0.0));
+ assert_eq!(Scene { size_mm: p(f64::NAN, 0.0), ..scene(vec![group(vec![stroke(bad, false, f64::NAN)])]) }.validate(), Err(REFUSED));
+ let mut count = Budget(MAX_RECORDS);
+ assert_eq!(count.add(usize::MAX), Err(REFUSED));
+}
+
+#[test]
+fn unknown_fields_kinds_and_ids_are_refused_when_read() {
+ let value = serde_json::to_value(a3()).unwrap();
+ let read = |v: serde_json::Value| serde_json::from_value::<Scene>(v);
+ read(value.clone()).unwrap();
+ for at in ["", "/groups/0", "/groups/0/items/0", "/groups/0/items/1"] {
+ let mut v = value.clone();
+ v.pointer_mut(at).unwrap()["layer"] = json!("A");
+ assert!(read(v).is_err(), "an unknown field at {at:?}");
+ }
+ let mut v = value.clone();
+ v["groups"][0]["items"][0]["kind"] = json!("text");
+ assert!(read(v).is_err());
+ for kind in ["frame", "Title Block", "TITLE_BLOCK", "titleblock", ""] {
+ let mut v = value.clone();
+ v["groups"][0]["kind"] = json!(kind);
+ assert!(read(v).is_err(), "{kind:?}");
+ }
+ // The id is any u64 and nothing else.
+ for object in [json!(-1), json!(1.5), json!("1"), json!(null)] {
+ let mut v = value.clone();
+ v["groups"][0]["object"] = object;
+ assert!(read(v).is_err());
+ }
+ let mut v = value.clone();
+ v["groups"][0]["object"] = json!("ID");
+ let with = |id: &str| serde_json::from_str::<Scene>(&serde_json::to_string(&v).unwrap().replace("\"ID\"", id));
+ with("1").unwrap();
+ assert!(with("18446744073709551616").is_err());
+ v["groups"][0].as_object_mut().unwrap().remove("object");
+ assert!(read(v).is_err());
+ let mut v = value;
+ v["groups"][0]["object"] = json!(u64::MAX);
+ read(v).unwrap().validate().unwrap();
+}
diff --git a/crates/geom/src/profile.rs b/crates/geom/src/profile.rs
index 7edc5985f1..21437c5ff4 100644
--- a/crates/geom/src/profile.rs
+++ b/crates/geom/src/profile.rs
@@ -58,6 +58,42 @@ pub const MAX_BEZIER_CTRL: usize = MAX_BEZIER_DEGREE + 1;
/// continuity order a blend curve can be built for (4 = G4).
pub const MAX_DERIVATIVE_ORDER: usize = 4;
+/// A similarity of the plane: a point is scaled by `scale` (above 0) about the origin, turned
+/// `angle` radians counter-clockwise, then moved by `shift`. It keeps shapes and the direction
+/// curves turn in, so an arc stays an arc ([`Seg2::similar`]).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Similarity2 {
+ scale: f64,
+ angle: f64,
+ shift: Vec2,
+ /// The angle's cosine and sine times the scale, worked out once rather than per point.
+ cos: f64,
+ sin: f64,
+}
+
+impl Similarity2 {
+ /// `None` unless `scale` is finite and above 0 and `angle` and `shift` are finite.
+ pub fn new(scale: f64, angle: f64, shift: Vec2) -> Option<Similarity2> {
+ if !(scale.is_finite() && scale > 0.0 && angle.is_finite() && shift.is_finite()) {
+ return None;
+ }
+ let (sin, cos) = angle.sin_cos();
+ Some(Similarity2 { scale, angle, shift, cos: cos * scale, sin: sin * scale })
+ }
+
+ pub fn scale(&self) -> f64 {
+ self.scale
+ }
+
+ pub fn angle(&self) -> f64 {
+ self.angle
+ }
+
+ pub fn apply(&self, p: Vec2) -> Vec2 {
+ Vec2::new(self.cos * p.x - self.sin * p.y, self.sin * p.x + self.cos * p.y) + self.shift
+ }
+}
+
/// A Bézier segment over `pts` (2…[`MAX_BEZIER_CTRL`] points): a line, a cubic or a higher-degree
/// piece. A quadratic becomes a conic of weight 1.
pub fn bezier(pts: &[Vec2]) -> Option<Seg2> {
@@ -76,6 +112,62 @@ pub fn bezier(pts: &[Vec2]) -> Option<Seg2> {
})
}
+/// Smallest radius, conic weight and absolute arc sweep [`Seg2::check`] accepts.
+const MIN_POSITIVE: f64 = 1e-12;
+/// Largest conic weight [`Seg2::check`] accepts.
+const MAX_WEIGHT: f64 = 1e12;
+/// Largest arc start angle either way, in radians, [`Seg2::check`] accepts.
+const MAX_START_ANGLE: f64 = 1e6;
+
+fn require(condition: bool, message: &'static str) -> Result<(), &'static str> {
+ if condition { Ok(()) } else { Err(message) }
+}
+
+/// Every value finite and at most `max_abs` in size: [`Seg2::check`]'s rule for coordinates, which
+/// `section` applies to its planes and contacts too.
+pub(crate) fn coordinates(values: impl IntoIterator<Item = f64>, max_abs: f64) -> Result<(), &'static str> {
+ require(values.into_iter().all(|v| v.is_finite() && v.abs() <= max_abs), "non-finite or excessive coordinate")
+}
+
+fn controls(points: &[Vec2], max_abs: f64) -> Result<(), &'static str> {
+ coordinates(points.iter().flat_map(|p| [p.x, p.y]), max_abs)?;
+ let Some((first, rest)) = points.split_first() else { return Err("empty controls") };
+ require(rest.iter().any(|p| p != first), "collapsed curve")
+}
+
+impl Seg2 {
+ /// Checks a segment read from outside before anything evaluates it: every stored coordinate
+ /// finite and at most `max_abs` in size (a Bézier's unused slots too, as they are serialized),
+ /// a radius in 1e-12..=`max_abs`, an arc's start within ±1e6 radians and its absolute sweep
+ /// 1e-12 to one turn (with 1e-12 radians of allowance), a conic weight in 1e-12..=1e12, a
+ /// Bézier degree of 4 to [`MAX_BEZIER_DEGREE`], controls not all at one point, and finite
+ /// ends. The limits keep evaluation finite; they promise no accuracy. The caller wraps the
+ /// message in its own error.
+ pub(crate) fn check(&self, max_abs: f64) -> Result<(), &'static str> {
+ match *self {
+ Seg2::Line { a, b } => controls(&[a, b], max_abs)?,
+ Seg2::Arc { center, radius, start, sweep } => {
+ coordinates([center.x, center.y], max_abs)?;
+ require(radius.is_finite() && (MIN_POSITIVE..=max_abs).contains(&radius), "arc radius")?;
+ require(start.is_finite() && start.abs() <= MAX_START_ANGLE, "arc start angle")?;
+ require(sweep.is_finite() && (MIN_POSITIVE..=TAU + 1e-12).contains(&sweep.abs()), "arc sweep")?;
+ }
+ Seg2::Cubic { p0, p1, p2, p3 } => controls(&[p0, p1, p2, p3], max_abs)?,
+ Seg2::Conic { a, apex, b, w } => {
+ controls(&[a, apex, b], max_abs)?;
+ require(w.is_finite() && (MIN_POSITIVE..=MAX_WEIGHT).contains(&w), "conic weight")?;
+ }
+ Seg2::Bezier { n, ref p } => {
+ require((4..=MAX_BEZIER_DEGREE).contains(&usize::from(n)), "Bezier degree")?;
+ // The unused slots are serialized too: reject hidden non-finite/excessive values.
+ coordinates(p.iter().flat_map(|q| [q.x, q.y]), max_abs)?;
+ controls(p.get(..=usize::from(n)).ok_or("Bezier degree")?, max_abs)?;
+ }
+ }
+ require(self.start().is_finite() && self.end().is_finite(), "non-finite curve endpoint")
+ }
+}
+
/// de Casteljau: the point at `t` and the two halves' control points.
fn casteljau(c: &[Vec2], t: f64) -> (Vec2, Vec<Vec2>, Vec<Vec2>) {
let mut w = c.to_vec();
@@ -318,6 +410,31 @@ impl Seg2 {
}
}
}
+ /// The segment with each control point mapped by `f`: exact for any affine map of lines,
+ /// Béziers and conics. An arc is returned as it is: only a similarity keeps it an arc
+ /// ([`Seg2::similar`]), and callers that mirror one handle it themselves.
+ pub fn map_controls(&self, f: impl Fn(Vec2) -> Vec2) -> Seg2 {
+ match *self {
+ Seg2::Line { a, b } => Seg2::Line { a: f(a), b: f(b) },
+ Seg2::Cubic { p0, p1, p2, p3 } => Seg2::Cubic { p0: f(p0), p1: f(p1), p2: f(p2), p3: f(p3) },
+ Seg2::Conic { a, apex, b, w } => Seg2::Conic { a: f(a), apex: f(apex), b: f(b), w },
+ Seg2::Bezier { n, mut p } => {
+ p.iter_mut().take(usize::from(n) + 1).for_each(|q| *q = f(*q));
+ Seg2::Bezier { n, p }
+ }
+ arc @ Seg2::Arc { .. } => arc,
+ }
+ }
+ /// The segment moved by the similarity `m`, exactly: an arc's centre maps, its radius scales
+ /// and its start turns; every other kind maps its control points.
+ pub fn similar(&self, m: &Similarity2) -> Seg2 {
+ match *self {
+ Seg2::Arc { center, radius, start, sweep } => {
+ Seg2::Arc { center: m.apply(center), radius: radius * m.scale(), start: start + m.angle(), sweep }
+ }
+ _ => self.map_controls(|p| m.apply(p)),
+ }
+ }
pub fn length(&self) -> f64 {
match *self {
Seg2::Line { a, b } => a.dist(b),
@@ -586,6 +703,10 @@ impl Region2 {
pub fn area(&self) -> f64 {
self.outer.signed_area().abs() - self.holes.iter().map(|h| h.signed_area().abs()).sum::<f64>()
}
+ /// The outer loop, then the holes.
+ pub fn loops(&self) -> impl Iterator<Item = &Loop2> + Clone {
+ std::iter::once(&self.outer).chain(&self.holes)
+ }
/// A point strictly inside the region (for picking and labels).
pub fn interior_point(&self) -> Vec2 {
let c = self.centroid();
diff --git a/crates/geom/src/section.rs b/crates/geom/src/section.rs
index ee2d99238e..ba3dcf6656 100644
--- a/crates/geom/src/section.rs
+++ b/crates/geom/src/section.rs
@@ -21,18 +21,15 @@
//! exact or certified measures for conics and freeform curves. Profile values contain geometry
//! only: callers retain the original result's accuracy declarations and local identities.
-use std::f64::consts::TAU;
-
use serde::{Deserialize, Serialize};
-use crate::{Loop2, MAX_BEZIER_DEGREE, Plane, Region2, Seg2, Vec2, Vec3};
+use crate::profile::coordinates;
+use crate::{Loop2, Plane, Region2, Seg2, Vec2, Vec3};
/// Aggregate input records/references, and the selected conversion's output items, at most.
/// Input counts curves, wires, regions, contacts, curve uses and hole references together.
pub const MAX_ITEMS: usize = 100_000;
-const MAX_NUMBER: f64 = 1e12;
-const MIN_POSITIVE: f64 = 1e-12;
-const MAX_START_ANGLE: f64 = 1e6;
+pub(crate) const MAX_NUMBER: f64 = 1e12;
const FRAME_TOLERANCE: f64 = 1e-8;
/// A section's geometric result, without source identity, freshness or persistence semantics.
@@ -68,6 +65,20 @@ pub enum CurveAccuracy {
Sampled { max_sample_deviation_mm: f64 },
}
+impl CurveAccuracy {
+ /// The same accuracy for the curve scaled by `factor` (above 0): a deviation scales with it,
+ /// and an analytic curve stays analytic.
+ pub fn scaled(self, factor: f64) -> CurveAccuracy {
+ match self {
+ CurveAccuracy::Analytic => CurveAccuracy::Analytic,
+ CurveAccuracy::Bounded { max_deviation_mm } => CurveAccuracy::Bounded { max_deviation_mm: max_deviation_mm * factor },
+ CurveAccuracy::Sampled { max_sample_deviation_mm } => {
+ CurveAccuracy::Sampled { max_sample_deviation_mm: max_sample_deviation_mm * factor }
+ }
+ }
+ }
+}
+
/// An ordered connected chain. `closed` is explicit, never inferred or repaired.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
@@ -111,16 +122,12 @@ impl Budget {
}
}
-fn numbers(values: impl IntoIterator<Item = f64>) -> Result<()> {
- require(values.into_iter().all(|v| v.is_finite() && v.abs() <= MAX_NUMBER), "non-finite or excessive coordinate")
-}
-
fn point(p: Vec2) -> Result<()> {
- numbers([p.x, p.y])
+ coordinates([p.x, p.y], MAX_NUMBER).map_err(Invalid)
}
fn vector(p: Vec3) -> Result<()> {
- numbers([p.x, p.y, p.z])
+ coordinates([p.x, p.y, p.z], MAX_NUMBER).map_err(Invalid)
}
/// Strictly check an existing plane without re-orthonormalizing it or changing its serde format.
@@ -137,38 +144,8 @@ pub fn validate_plane(plane: &Plane) -> Result<()> {
)
}
-fn controls(points: &[Vec2]) -> Result<()> {
- for p in points {
- point(*p)?;
- }
- let Some((first, rest)) = points.split_first() else { return Err(Invalid("empty controls")) };
- require(rest.iter().any(|p| p != first), "collapsed curve")
-}
-
fn curve(curve: &SectionCurve) -> Result<()> {
- match curve.geometry {
- Seg2::Line { a, b } => controls(&[a, b])?,
- Seg2::Arc { center, radius, start, sweep } => {
- point(center)?;
- require(radius.is_finite() && (MIN_POSITIVE..=MAX_NUMBER).contains(&radius), "arc radius")?;
- require(start.is_finite() && start.abs() <= MAX_START_ANGLE, "arc start angle")?;
- require(sweep.is_finite() && (MIN_POSITIVE..=TAU + 1e-12).contains(&sweep.abs()), "arc sweep")?;
- }
- Seg2::Cubic { p0, p1, p2, p3 } => controls(&[p0, p1, p2, p3])?,
- Seg2::Conic { a, apex, b, w } => {
- controls(&[a, apex, b])?;
- require(w.is_finite() && (MIN_POSITIVE..=MAX_NUMBER).contains(&w), "conic weight")?;
- }
- Seg2::Bezier { n, ref p } => {
- require((4..=MAX_BEZIER_DEGREE).contains(&usize::from(n)), "Bezier degree")?;
- // The unused slots are serialized too: reject hidden non-finite/excessive values.
- for q in p {
- point(*q)?;
- }
- controls(p.get(..=usize::from(n)).ok_or(Invalid("Bezier degree"))?)?;
- }
- }
- require(curve.geometry.start().is_finite() && curve.geometry.end().is_finite(), "non-finite curve endpoint")?;
+ curve.geometry.check(MAX_NUMBER).map_err(Invalid)?;
match curve.accuracy {
CurveAccuracy::Analytic => Ok(()),
CurveAccuracy::Bounded { max_deviation_mm } => deviation(max_deviation_mm),
diff --git a/crates/geom/src/section_tests.rs b/crates/geom/src/section_tests.rs
index 961409ac81..7feb71c72f 100644
--- a/crates/geom/src/section_tests.rs
+++ b/crates/geom/src/section_tests.rs
@@ -1,4 +1,4 @@
-use std::f64::consts::PI;
+use std::f64::consts::{PI, TAU};
use super::*;
use crate::{MAX_BEZIER_CTRL, bezier};
@@ -407,3 +407,17 @@ fn connected_bow_tie_and_wrong_winding_are_not_certified_or_silently_repaired()
let converted = reversed.to_region(0, TOL).unwrap();
assert!((converted.outer.signed_area() + 6000.0).abs() < 1e-10);
}
+
+/// A curve's accuracy scales with it: a bound or a sampled deviation by the factor, and an analytic
+/// curve stays analytic (W17a: paper error = scale × model error).
+#[test]
+fn an_accuracy_scales_with_its_curve() {
+ assert_eq!(CurveAccuracy::Analytic.scaled(0.5), CurveAccuracy::Analytic);
+ assert_eq!(CurveAccuracy::Sampled { max_sample_deviation_mm: 0.01 }.scaled(3.0), CurveAccuracy::Sampled { max_sample_deviation_mm: 0.03 });
+ assert_eq!(CurveAccuracy::Bounded { max_deviation_mm: 0.01 }.scaled(2.0), CurveAccuracy::Bounded { max_deviation_mm: 0.02 });
+ assert_eq!(
+ CurveAccuracy::Sampled { max_sample_deviation_mm: 0.0 }.scaled(5.0),
+ CurveAccuracy::Sampled { max_sample_deviation_mm: 0.0 },
+ "a sampled zero stays sampled"
+ );
+}
diff --git a/crates/geom/src/tests.rs b/crates/geom/src/tests.rs
index ab614f0e4e..6ff94beefd 100644
--- a/crates/geom/src/tests.rs
+++ b/crates/geom/src/tests.rs
@@ -847,3 +847,48 @@ fn a_box_from_points_holds_them_and_grows() {
assert_eq!((both.min, both.max), (Vec3::new(0.0, 1.0, 4.0), Vec3::new(1.0, 2.0, 5.0)));
assert!(b.intersection(&far).is_empty());
}
+
+/// A similarity moves every kind of segment exactly: the moved segment's points are the original's
+/// points moved, its length scales, and an arc stays an arc turning the same way.
+#[test]
+fn a_similarity_moves_each_kind_of_segment_exactly() {
+ let m = Similarity2::new(2.5, 0.7, Vec2::new(-3.0, 11.0)).unwrap();
+ let mut p = [Vec2::ZERO; MAX_BEZIER_CTRL];
+ for (i, q) in p.iter_mut().take(6).enumerate() {
+ *q = Vec2::new(i as f64, (i * i) as f64 * 0.3);
+ }
+ let segments = [
+ Seg2::Line { a: Vec2::new(1.0, 2.0), b: Vec2::new(4.0, -1.0) },
+ Seg2::Arc { center: Vec2::new(2.0, 1.0), radius: 3.0, start: 0.4, sweep: -2.1 },
+ Seg2::Cubic { p0: Vec2::ZERO, p1: Vec2::new(1.0, 2.0), p2: Vec2::new(3.0, 2.0), p3: Vec2::new(4.0, 0.0) },
+ Seg2::Conic { a: Vec2::new(10.0, 0.0), apex: Vec2::new(10.0, 10.0), b: Vec2::new(0.0, 10.0), w: std::f64::consts::FRAC_1_SQRT_2 },
+ Seg2::Bezier { n: 5, p },
+ ];
+ for seg in segments {
+ let moved = seg.similar(&m);
+ for i in 0..=8 {
+ let t = f64::from(i) / 8.0;
+ assert!((moved.point_at(t) - m.apply(seg.point_at(t))).len() < 1e-9, "{seg:?} at {t}");
+ }
+ assert!((moved.length() - seg.length() * m.scale()).abs() < 1e-9 * seg.length().max(1.0), "{seg:?}");
+ assert_eq!(std::mem::discriminant(&moved), std::mem::discriminant(&seg));
+ }
+ // An arc keeps its sweep: the turning direction survives a similarity.
+ let arc = Seg2::Arc { center: Vec2::ZERO, radius: 1.0, start: 0.0, sweep: -1.0 };
+ assert!(matches!(arc.similar(&m), Seg2::Arc { sweep, .. } if sweep == -1.0));
+ // The identity changes nothing.
+ let identity = Similarity2::new(1.0, 0.0, Vec2::ZERO).unwrap();
+ for seg in segments {
+ assert_eq!(seg.similar(&identity), seg);
+ }
+ // A similarity scales by a finite number above 0, and turns and moves by finite ones.
+ for (scale, angle, shift) in [
+ (0.0, 0.0, Vec2::ZERO),
+ (-1.0, 0.0, Vec2::ZERO),
+ (f64::NAN, 0.0, Vec2::ZERO),
+ (1.0, f64::INFINITY, Vec2::ZERO),
+ (1.0, 0.0, Vec2::new(f64::NAN, 0.0)),
+ ] {
+ assert!(Similarity2::new(scale, angle, shift).is_none(), "{scale} {angle} {shift:?}");
+ }
+}
diff --git a/crates/geom/src/title_block.rs b/crates/geom/src/title_block.rs
new file mode 100644
index 0000000000..8efc6bc72c
--- /dev/null
+++ b/crates/geom/src/title_block.rs
@@ -0,0 +1,230 @@
+//! Title blocks: the block of cells that identifies a drawing and what its sheet documents, as
+//! data in sheet millimetres.
+//!
+//! A [`TitleBlock`] is a definition: its size, its two line widths and its cells. Each [`Cell`] is
+//! a rectangle measured from the block's lower-right corner (x at most 0, y at least 0), with a
+//! label and a value: text from cell content ([`crate::cell`]), or the projection symbol. The block
+//! sits on the drawing border's lower-right corner, so one definition serves every sheet it fits.
+//! [`TitleBlock::validate`] checks a definition on its own, as when one is read, and
+//! [`TitleBlock::layout`] places it on one sheet by the cell text rule: each cell's rectangle, where
+//! its label goes and the box its value goes in. Values are set in their boxes once the paper scene
+//! has text; nothing here is saved or drawn yet.
+//!
+//! The outline is drawn `outline_line_mm` wide and the lines between cells `cell_line_mm`, each
+//! centred on its edge. The block's right and bottom edges lie on the drawing border, whose line is
+//! centred there too. A cell's text is padded from the inner edge of its lines and of the border's
+//! line, wherever that reaches, and its descenders never reach a line (the cell text rule), so no
+//! line covers it.
+
+use serde::{Deserialize, Serialize};
+
+use crate::cell::{self, Content, Fit, HAlign};
+use crate::drawing_sheet::SheetLayout;
+use crate::paper::MAX_LINE_MM;
+use crate::{Aabb2, Vec2};
+
+/// The most cells a block may have.
+pub const MAX_CELLS: usize = 64;
+const MIN_BLOCK_SIDE_MM: f64 = 1.0;
+const MAX_BLOCK_SIDE_MM: f64 = 1000.0;
+const MAX_NAME_BYTES: usize = 64;
+
+/// A title block's definition.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct TitleBlock {
+ /// The block's width and height.
+ pub size_mm: Vec2,
+ pub outline_line_mm: f64,
+ pub cell_line_mm: f64,
+ pub cells: Vec<Cell>,
+}
+
+/// One cell of a block.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct Cell {
+ /// Snake case, and no other cell of the block has it.
+ pub name: String,
+ /// `[x0, y0, x1, y1]` from the block's lower-right corner: `-width <= x0 < x1 <= 0` and
+ /// `0 <= y0 < y1 <= height`.
+ pub rect_mm: [f64; 4],
+ /// None: the value has the whole cell.
+ pub label: Option<Label>,
+ pub kind: CellKind,
+}
+
+/// A cell's label, such as "Created by": one line at its top left.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct Label {
+ pub text: String,
+ pub cap_mm: f64,
+}
+
+/// What a cell's value is. Externally tagged (`{"text": {...}}`, `"projection_symbol"`), as serde
+/// ignores extra fields on an internally tagged unit variant.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case", deny_unknown_fields)]
+pub enum CellKind {
+ Text(TextCell),
+ /// The projection symbol, drawn from the drawing's projection (`drawing.projection`), which the
+ /// views read too: never fixed in the block.
+ ProjectionSymbol,
+}
+
+/// A text value: its content, its cap height, where its lines sit across the value box (left when
+/// not given) and what it should fit (nothing when not given).
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct TextCell {
+ pub content: Content,
+ pub cap_mm: f64,
+ #[serde(default)]
+ pub align: HAlign,
+ #[serde(default)]
+ pub fit: Fit,
+}
+
+/// A block placed on one sheet: what a writer draws, before the values are set.
+#[derive(Clone, Debug, PartialEq)]
+pub struct TitleBlockLayout {
+ pub outline: Aabb2,
+ pub outline_line_mm: f64,
+ pub cell_line_mm: f64,
+ /// One for each of the definition's cells, in its order.
+ pub cells: Vec<CellLayout>,
+}
+
+/// One cell placed on a sheet.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct CellLayout {
+ pub rect: Aabb2,
+ /// Where the label's baseline starts, when the cell has one.
+ pub label_at: Option<Vec2>,
+ pub value_box: Aabb2,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
+#[error("title block: {0}")]
+pub struct Invalid(pub &'static str);
+
+type Result<T> = std::result::Result<T, Invalid>;
+
+fn require(condition: bool, message: &'static str) -> Result<()> {
+ if condition { Ok(()) } else { Err(Invalid(message)) }
+}
+
+/// A lowercase letter, then lowercase letters, digits and underscores: at most 64 in all.
+fn is_snake_case(name: &str) -> bool {
+ let mut bytes = name.bytes();
+ name.len() <= MAX_NAME_BYTES
+ && bytes.next().is_some_and(|b| b.is_ascii_lowercase())
+ && bytes.all(|b| b.is_ascii_lowercase() || b.is_ascii_digit() || b == b'_')
+}
+
+/// Whether two rectangles share more than an edge.
+fn overlap(a: Aabb2, b: Aabb2) -> bool {
+ a.min.x < b.max.x && b.min.x < a.max.x && a.min.y < b.max.y && b.min.y < a.max.y
+}
+
+impl Cell {
+ /// The cell's rectangle with the block's lower-right corner at `corner`.
+ fn rect(&self, corner: Vec2) -> Aabb2 {
+ let [x0, y0, x1, y1] = self.rect_mm;
+ Aabb2 { min: corner + Vec2::new(x0, y0), max: corner + Vec2::new(x1, y1) }
+ }
+
+ /// The box its value goes in, in `inside`, the cell inside its lines.
+ fn value_box(&self, inside: Aabb2) -> Aabb2 {
+ cell::value_box(inside, self.label.as_ref().map(|label| label.cap_mm))
+ }
+}
+
+impl TitleBlock {
+ /// `cell`'s rectangle `rect` inside its lines: each side moved in by half the line drawn on it,
+ /// the outline's on the block's edges and a cell line's inside the block.
+ fn inside_lines(&self, cell: &Cell, rect: Aabb2) -> Aabb2 {
+ let [x0, y0, x1, y1] = cell.rect_mm;
+ let half = |on_outline: bool| if on_outline { self.outline_line_mm } else { self.cell_line_mm } / 2.0;
+ let lower = Vec2::new(half(x0 == -self.size_mm.x), half(y0 == 0.0));
+ let upper = Vec2::new(half(x1 == 0.0), half(y1 == self.size_mm.y));
+ Aabb2 { min: rect.min + lower, max: rect.max - upper }
+ }
+
+ /// Each cell with the block's lower-right corner at `corner`, inside its lines and inside
+ /// `clear` too when given (the drawing border's line's inner edge), checked by the cell text
+ /// rule: room for a value below its label, and for one line of a text value.
+ fn place_cells(&self, corner: Vec2, clear: Option<Aabb2>) -> Result<Vec<CellLayout>> {
+ let place = |cell: &Cell| {
+ let rect = cell.rect(corner);
+ let inside = self.inside_lines(cell, rect);
+ let inside = clear.map_or(inside, |clear| inside.intersection(&clear));
+ let value_box = cell.value_box(inside);
+ let room = value_box.size();
+ require(room.x > 0.0 && room.y > 0.0, "a cell has room for its value below its label")?;
+ if let CellKind::Text(text) = &cell.kind {
+ let one_line = cell::place_lines(value_box, 1, text.cap_mm, text.cap_mm, text.align, false);
+ require(matches!(one_line, Ok((_, None))), "a value's cap height is above 0 and one line of it fits its value box")?;
+ }
+ let label_at = cell.label.as_ref().map(|label| cell::label_at(inside, label.cap_mm));
+ Ok(CellLayout { rect, label_at, value_box })
+ };
+ self.cells.iter().map(place).collect()
+ }
+
+ /// Checks a definition on its own, counting its cells first: call it when one is read. Its
+ /// cells' room is checked with the corner at the origin and only the outline on its edges;
+ /// [`Self::layout`] calls it too, and checks their room again where the block sits.
+ pub fn validate(&self) -> Result<()> {
+ require(self.cells.len() <= MAX_CELLS, "a title block has at most 64 cells")?;
+ let Vec2 { x: width, y: height } = self.size_mm;
+ let sides = MIN_BLOCK_SIDE_MM..=MAX_BLOCK_SIDE_MM;
+ require(sides.contains(&width) && sides.contains(&height), "each side of a title block is 1 to 1000 mm")?;
+ let lines = [self.outline_line_mm, self.cell_line_mm];
+ require(lines.into_iter().all(|line| line > 0.0 && line <= MAX_LINE_MM), "a title block's lines are above 0 and at most 10 mm wide")?;
+ for (i, cell) in self.cells.iter().enumerate() {
+ let earlier = || self.cells.iter().take(i);
+ require(is_snake_case(&cell.name), "a cell's name is snake case and at most 64 characters")?;
+ require(earlier().all(|other| other.name != cell.name), "no two cells have the same name")?;
+ let [x0, y0, x1, y1] = cell.rect_mm;
+ require(-width <= x0 && x0 < x1 && x1 <= 0.0 && 0.0 <= y0 && y0 < y1 && y1 <= height, "a cell lies inside its block")?;
+ let rect = cell.rect(Vec2::ZERO);
+ require(earlier().all(|other| !overlap(other.rect(Vec2::ZERO), rect)), "no two cells overlap")?;
+ if let Some(label) = &cell.label {
+ require(label.cap_mm.is_finite() && label.cap_mm > 0.0, "a label's cap height is finite and above 0")?;
+ cell::check_label(&label.text).map_err(|cell::Invalid(message)| Invalid(message))?;
+ }
+ if let CellKind::Text(text) = &cell.kind {
+ text.content.validate().map_err(|cell::Invalid(message)| Invalid(message))?;
+ }
+ }
+ self.place_cells(Vec2::ZERO, None)?;
+ Ok(())
+ }
+
+ /// The block on the lower-right corner of `sheet`'s drawing border, which must hold it, each
+ /// cell with room inside the border's line too.
+ pub fn layout(&self, sheet: &SheetLayout) -> Result<TitleBlockLayout> {
+ self.validate()?;
+ let border = sheet.drawing_border;
+ let (size, room) = (self.size_mm, border.size());
+ let fits = border.min.is_finite() && border.max.is_finite() && size.x <= room.x && size.y <= room.y;
+ require(fits, "a title block fits inside the drawing border")?;
+ let corner = Vec2::new(border.max.x, border.min.y);
+ // Checked again here: the border's line, centred on it, runs along the block's right and
+ // bottom edges (and any other it reaches), and rounding at the real corner may take the
+ // last of a cell's room.
+ let cells = self.place_cells(corner, Some(border.inflated(-sheet.drawing_border_line_mm / 2.0)))?;
+ Ok(TitleBlockLayout {
+ outline: Aabb2 { min: corner - Vec2::new(size.x, 0.0), max: corner + Vec2::new(0.0, size.y) },
+ outline_line_mm: self.outline_line_mm,
+ cell_line_mm: self.cell_line_mm,
+ cells,
+ })
+ }
+}
+
+#[cfg(test)]
+#[path = "title_block_tests.rs"]
+mod tests;
diff --git a/crates/geom/src/title_block_tests.rs b/crates/geom/src/title_block_tests.rs
new file mode 100644
index 0000000000..a4005659eb
--- /dev/null
+++ b/crates/geom/src/title_block_tests.rs
@@ -0,0 +1,545 @@
+use serde_json::json;
+
+use super::*;
+use crate::bspline::tests::Lcg;
+use crate::cell::{DESCENDER_OF_CAP, Format, PADDING_MM, Part, Source, Warning, place_lines};
+use crate::drawing_sheet::{DrawingBorderProfile, Orientation, PaperSize, Sheet, SheetSize};
+
+fn rect(x0: f64, y0: f64, x1: f64, y1: f64) -> Aabb2 {
+ Aabb2 { min: Vec2::new(x0, y0), max: Vec2::new(x1, y1) }
+}
+
+fn field(source: Source, key: &str) -> Part {
+ Part::Field { source, key: key.to_string(), format: Format::default() }
+}
+
+fn text(cap_mm: f64, align: HAlign, fit: Fit, parts: Vec<Part>) -> CellKind {
+ CellKind::Text(TextCell { content: Content(parts), cap_mm, align, fit })
+}
+
+/// The S2 plan's 180 x 54 mm default, as test data: twelve cells under 2.5 mm labels.
+fn block() -> TitleBlock {
+ use HAlign::{Centre, Left};
+ use Source::{Component, Drawing, Revision};
+ let count = |n| Fit { max_chars: Some(n), ..Fit::default() };
+ let (whole, wrap) = (Fit::default(), Fit { wrap: true, ..Fit::default() });
+ let title = Fit { max_chars: Some(25), wide_max_chars: Some(30), wrap: false };
+ let sheet = vec![field(Source::Sheet, "number"), Part::Text("/".into()), field(Source::Sheet, "count")];
+ let cells = [
+ ("title", [-180.0, 0.0, -68.0, 14.0], "Title", text(5.0, Left, title, vec![field(Component, "name")])),
+ ("identification_number", [-68.0, 0.0, 0.0, 14.0], "Identification number", text(5.0, Left, count(16), vec![field(Drawing, "number")])),
+ ("created_by", [-180.0, 14.0, -121.0, 24.0], "Created by", text(3.5, Left, count(20), vec![field(Revision, "designer")])),
+ ("approved_by", [-121.0, 14.0, -62.0, 24.0], "Approved by", text(3.5, Left, count(20), vec![field(Revision, "checker")])),
+ ("date_of_issue", [-62.0, 14.0, -31.0, 24.0], "Date of issue", text(3.5, Left, count(10), vec![field(Revision, "date")])),
+ ("sheet", [-31.0, 14.0, 0.0, 24.0], "Sheet", text(3.5, Centre, count(9), sheet)),
+ ("material", [-180.0, 24.0, -100.0, 34.0], "Material", text(3.5, Left, whole, vec![field(Component, "material")])),
+ ("finish", [-100.0, 24.0, -30.0, 34.0], "Finish", text(3.5, Left, whole, vec![field(Component, "properties.finish")])),
+ ("mass", [-30.0, 24.0, 0.0, 34.0], "Mass", text(3.5, Centre, whole, vec![field(Component, "mass")])),
+ ("legal_owner", [-180.0, 34.0, -100.0, 54.0], "Legal owner", text(3.5, Left, wrap, vec![field(Drawing, "properties.legal_owner")])),
+ (
+ "general_tolerances",
+ [-100.0, 34.0, -30.0, 54.0],
+ "General tolerances",
+ text(2.5, Left, wrap, vec![field(Drawing, "properties.general_tolerances")]),
+ ),
+ ("projection", [-30.0, 34.0, 0.0, 54.0], "Projection", CellKind::ProjectionSymbol),
+ ];
+ let cells = cells
+ .into_iter()
+ .map(|(name, rect_mm, label, kind)| Cell { name: name.into(), rect_mm, label: Some(Label { text: label.into(), cap_mm: 2.5 }), kind })
+ .collect();
+ TitleBlock { size_mm: Vec2::new(180.0, 54.0), outline_line_mm: 0.7, cell_line_mm: 0.35, cells }
+}
+
+fn sheet_layout(profile: &DrawingBorderProfile, size: PaperSize, orientation: Orientation) -> SheetLayout {
+ profile.layout(&Sheet::standard(size, orientation)).unwrap()
+}
+
+fn iso(size: PaperSize, orientation: Orientation) -> SheetLayout {
+ sheet_layout(&DrawingBorderProfile::iso(), size, orientation)
+}
+
+fn filing(size: PaperSize, orientation: Orientation) -> SheetLayout {
+ sheet_layout(&DrawingBorderProfile { filing_margin: true, ..DrawingBorderProfile::iso() }, size, orientation)
+}
+
+fn cell_named<'a>(block: &TitleBlock, layout: &'a TitleBlockLayout, name: &str) -> &'a CellLayout {
+ let i = block.cells.iter().position(|c| c.name == name).unwrap();
+ &layout.cells[i]
+}
+
+/// `a` and `b` within 1e-9 mm at both corners.
+fn near(a: Aabb2, b: Aabb2) -> bool {
+ a.min.dist(b.min) < 1e-9 && a.max.dist(b.max) < 1e-9
+}
+
+/// `cell`'s rectangle placed at `corner`, inside its lines by the module's rule worked out by hand:
+/// half the 0.7 mm outline on the block's edges, half the 0.35 mm cell line inside.
+fn inside(cell: &Cell, corner: Vec2) -> Aabb2 {
+ let [x0, y0, x1, y1] = cell.rect_mm;
+ let half = |outline: bool| if outline { 0.35 } else { 0.175 };
+ Aabb2 {
+ min: corner + Vec2::new(x0 + half(x0 == -180.0), y0 + half(y0 == 0.0)),
+ max: corner + Vec2::new(x1 - half(x1 == 0.0), y1 - half(y1 == 54.0)),
+ }
+}
+
+fn text_of(cell: &Cell) -> &TextCell {
+ match &cell.kind {
+ CellKind::Text(text) => text,
+ CellKind::ProjectionSymbol => panic!("{} has no text", cell.name),
+ }
+}
+
+#[test]
+fn the_default_geometry_validates_and_its_cells_tile_the_block() {
+ let block = block();
+ block.validate().unwrap();
+ assert_eq!(block.cells.len(), 12);
+ let area: f64 = block.cells.iter().map(|c| c.rect(Vec2::ZERO).size()).map(|s| s.x * s.y).sum();
+ assert_eq!((area, 180.0 * 54.0), (9720.0, 9720.0));
+ // Each text cell's value box holds one line of its cap height, centred, its descenders above the
+ // lines' inner edge.
+ for cell in &block.cells {
+ let room = cell.value_box(block.inside_lines(cell, cell.rect(Vec2::ZERO))).size();
+ if let CellKind::Text(text) = &cell.kind {
+ let below = (room.y - text.cap_mm) / 2.0 + PADDING_MM;
+ assert!(text.cap_mm <= room.y && text.cap_mm * DESCENDER_OF_CAP <= below, "{}: {} in {room:?}", cell.name, text.cap_mm);
+ }
+ }
+}
+
+#[test]
+fn on_a3_landscape_the_block_sits_on_the_drawing_borders_lower_right_corner() {
+ let (block, sheet) = (block(), iso(PaperSize::A3, Orientation::Landscape));
+ let layout = block.layout(&sheet).unwrap();
+ assert_eq!(layout.outline, rect(230.0, 10.0, 410.0, 64.0));
+ assert_eq!(layout.outline.size().x, 180.0);
+ assert_eq!((layout.outline_line_mm, layout.cell_line_mm), (0.7, 0.35));
+ assert_eq!(layout.cells.len(), 12);
+ // The title cell, on the outline at its left and bottom (0.35 mm in), a cell line at its right
+ // and top (0.175 in): its label's baseline 1 + 2.5 mm below its top's inner edge, its value box
+ // 1 mm in from the lines' inner edges and 1 mm under the label.
+ let title = cell_named(&block, &layout, "title");
+ assert_eq!(title.rect, rect(230.0, 10.0, 342.0, 24.0));
+ assert!(title.label_at.is_some_and(|at| at.dist(Vec2::new(231.35, 20.325)) < 1e-9), "{:?}", title.label_at);
+ assert!(near(title.value_box, rect(231.35, 11.35, 340.825, 19.325)), "{:?}", title.value_box);
+ let (at, warning) = place_lines(title.value_box, 1, 5.0, 8.0, HAlign::Left, false).unwrap();
+ assert!(at.dist(Vec2::new(231.35, 12.8375)) < 1e-9 && warning.is_none(), "{at:?}");
+ // The projection cell, on the outline at its right and top.
+ let projection = cell_named(&block, &layout, "projection");
+ assert_eq!(projection.rect, rect(380.0, 44.0, 410.0, 64.0));
+ assert!(projection.label_at.is_some_and(|at| at.dist(Vec2::new(381.175, 60.15)) < 1e-9), "{:?}", projection.label_at);
+ assert!(near(projection.value_box, rect(381.175, 45.175, 408.65, 59.15)), "{:?}", projection.value_box);
+ // A cell without a label gives its value the whole cell inside its lines, padded.
+ let mut bare = block.clone();
+ bare.cells[0].label = None;
+ let title = bare.layout(&sheet).unwrap().cells[0];
+ assert!(title.label_at.is_none() && near(title.value_box, rect(231.35, 11.35, 340.825, 22.825)), "{:?}", title.value_box);
+}
+
+/// Padding is measured from a line's inner edge: a 3 mm outline moves the title's text 1.5 mm in
+/// from where a hairline puts it, so the line never covers it. The drawing border's line is a
+/// hairline too, so only the outline moves the text.
+#[test]
+fn the_padding_starts_at_the_lines_inner_edge() {
+ let sheet = SheetLayout { drawing_border_line_mm: 1e-9, ..iso(PaperSize::A3, Orientation::Landscape) };
+ let hairline = TitleBlock { outline_line_mm: 1e-9, cell_line_mm: 1e-9, ..block() }.layout(&sheet).unwrap();
+ let wide = TitleBlock { outline_line_mm: 3.0, ..block() }.layout(&sheet).unwrap();
+ let (thin, thick) = (hairline.cells[0].value_box, wide.cells[0].value_box);
+ assert!((thick.min.x - thin.min.x - 1.5).abs() < 1e-6 && (thick.min.y - thin.min.y - 1.5).abs() < 1e-6, "{thin:?} {thick:?}");
+ // The outline's inner edge is 1.5 mm inside the cell's left side; the text starts 1 mm past it.
+ assert!((thick.min.x - (230.0 + 1.5 + 1.0)).abs() < 1e-9, "{thick:?}");
+}
+
+/// The block's right and bottom edges lie on the drawing border, its line centred on them too: where
+/// that line is wider than the outline, the cells there are padded from its inner edge instead.
+#[test]
+fn a_drawing_border_line_wider_than_the_outline_pads_the_right_and_bottom_cells() {
+ let a3 = |line_mm: f64| SheetLayout { drawing_border_line_mm: line_mm, ..iso(PaperSize::A3, Orientation::Landscape) };
+ let block = block();
+ let boxes = |block: &TitleBlock, line_mm: f64| {
+ let layout = block.layout(&a3(line_mm)).unwrap();
+ ["title", "identification_number", "projection"].map(|name| cell_named(block, &layout, name).value_box)
+ };
+ // ISO's 0.7 mm, the outline's width, and a narrower line leave the outline's inner edge.
+ assert_eq!(boxes(&block, 0.35), boxes(&block, 0.7));
+ // A 2 mm line's inner edge is at y = 11 and x = 409: the value boxes start 1 mm above it and end
+ // 1 mm left of it; the block's left and top edges keep the outline's.
+ let [title, number, projection] = boxes(&block, 2.0);
+ assert!(near(title, rect(231.35, 12.0, 340.825, 19.325)), "{title:?}");
+ assert!(near(number, rect(343.175, 12.0, 408.0, 19.325)), "{number:?}");
+ assert!(near(projection, rect(381.175, 45.175, 408.0, 59.15)), "{projection:?}");
+ // A 5 mm line's inner edge is at y = 12.5 and x = 407.5: the title's 5 mm line no longer fits
+ // above it, so the block that validates on its own is refused on this sheet. With 3.5 mm values,
+ // the boxes keep 1 mm from it.
+ block.validate().unwrap();
+ assert_eq!(block.layout(&a3(5.0)), Err(Invalid("a value's cap height is above 0 and one line of it fits its value box")));
+ let mut smaller = block.clone();
+ for cell in &mut smaller.cells[..2] {
+ if let CellKind::Text(text) = &mut cell.kind {
+ text.cap_mm = 3.5;
+ }
+ }
+ let [title, number, _] = boxes(&smaller, 5.0);
+ assert!(near(title, rect(231.35, 13.5, 340.825, 19.325)) && near(number, rect(343.175, 13.5, 406.5, 19.325)), "{title:?} {number:?}");
+ // A block that fills the drawing border has its left and top edges on the border's line too:
+ // on a 200 x 74 sheet the border is (10, 10)-(190, 64), and a 2 mm line's inner edge is at x = 11
+ // and y = 63.
+ let sheet = |sides_mm| Sheet { size: SheetSize::Custom { sides_mm }, orientation: Orientation::Landscape };
+ let filled = SheetLayout { drawing_border_line_mm: 2.0, ..DrawingBorderProfile::iso().layout(&sheet([200.0, 74.0])).unwrap() };
+ let layout = block.layout(&filled).unwrap();
+ let (title, projection) = (cell_named(&block, &layout, "title"), cell_named(&block, &layout, "projection"));
+ assert!(near(title.value_box, rect(12.0, 12.0, 120.825, 19.325)), "{:?}", title.value_box);
+ assert!(projection.label_at.is_some_and(|at| at.dist(Vec2::new(161.175, 59.5)) < 1e-9), "{:?}", projection.label_at);
+ assert!(near(projection.value_box, rect(161.175, 45.175, 188.0, 58.5)), "{:?}", projection.value_box);
+}
+
+/// A cell with a few ulps of room at the origin, where a definition is checked on its own, has none
+/// where A3's corner (x = 410) rounds it: the block is refused there, not laid out inside out, and
+/// placed where rounding leaves the room (A2's corner, x = 584).
+#[test]
+fn a_cells_room_is_checked_again_where_the_block_sits() {
+ let sliver = Cell { rect_mm: [-70.34999999999971, 0.0, -67.9999999999997, 14.0], ..block().cells[0].clone() };
+ let block = TitleBlock { cells: vec![sliver], ..block() };
+ block.validate().unwrap();
+ const NO_ROOM: Invalid = Invalid("a cell has room for its value below its label");
+ assert_eq!(block.layout(&iso(PaperSize::A3, Orientation::Landscape)), Err(NO_ROOM));
+ let value_box = block.layout(&iso(PaperSize::A2, Orientation::Landscape)).unwrap().cells[0].value_box;
+ assert!(value_box.min.x < value_box.max.x, "{value_box:?}");
+}
+
+#[test]
+fn the_block_follows_the_drawing_border_on_a2_and_a4() {
+ let block = block();
+ assert_eq!(block.layout(&iso(PaperSize::A2, Orientation::Landscape)).unwrap().outline, rect(404.0, 10.0, 584.0, 64.0));
+ // A4 upright: 10 mm to spare on the left of the 190 mm drawing border, none with the filing margin.
+ let a4 = iso(PaperSize::A4, Orientation::Portrait);
+ assert_eq!(a4.drawing_border, rect(10.0, 10.0, 200.0, 287.0));
+ assert_eq!(block.layout(&a4).unwrap().outline, rect(20.0, 10.0, 200.0, 64.0));
+ let a4 = filing(PaperSize::A4, Orientation::Portrait);
+ let outline = block.layout(&a4).unwrap().outline;
+ assert_eq!((outline.min.x, outline), (a4.drawing_border.min.x, rect(20.0, 10.0, 200.0, 64.0)));
+}
+
+#[test]
+fn a5_landscape_holds_the_block_and_a5_portrait_is_too_narrow() {
+ const TOO_BIG: Invalid = Invalid("a title block fits inside the drawing border");
+ let block = block();
+ assert_eq!(block.layout(&iso(PaperSize::A5, Orientation::Landscape)).unwrap().outline, rect(20.0, 10.0, 200.0, 64.0));
+ // With the filing margin, the drawing border is exactly the block's width.
+ let a5 = filing(PaperSize::A5, Orientation::Landscape);
+ assert_eq!(a5.drawing_border.size().x, 180.0);
+ assert_eq!(block.layout(&a5).unwrap().outline, rect(20.0, 10.0, 200.0, 64.0));
+ // Upright, the drawing border is 128 mm wide, or 118 with the filing margin.
+ for sheet in [iso(PaperSize::A5, Orientation::Portrait), filing(PaperSize::A5, Orientation::Portrait)] {
+ assert!(sheet.drawing_border.size().x < 180.0);
+ assert_eq!(block.layout(&sheet), Err(TOO_BIG));
+ }
+ // A drawing border of exactly 180 x 54 holds it; a hair less either way doesn't.
+ let custom = |a: f64, b: f64| {
+ DrawingBorderProfile::iso().layout(&Sheet { size: SheetSize::Custom { sides_mm: [a, b] }, orientation: Orientation::Landscape })
+ };
+ let exact = custom(200.0, 74.0).unwrap();
+ assert_eq!(block.layout(&exact).unwrap().outline, exact.drawing_border);
+ for sheet in [custom(199.999, 74.0), custom(200.0, 73.999)] {
+ assert_eq!(block.layout(&sheet.unwrap()), Err(TOO_BIG));
+ }
+}
+
+/// On every standard sheet either way, with the filing margin or without, the block sits on the
+/// drawing border's lower-right corner and each cell keeps its place from it; only A5 upright is
+/// too narrow.
+#[test]
+fn on_every_sheet_each_cell_keeps_its_place_from_the_corner() {
+ let block = block();
+ let mut refused = Vec::new();
+ for size in PaperSize::ALL {
+ for orientation in [Orientation::Landscape, Orientation::Portrait] {
+ for sheet in [iso(size, orientation), filing(size, orientation)] {
+ let border = sheet.drawing_border;
+ let Ok(layout) = block.layout(&sheet) else {
+ assert!(border.size().x < 180.0 || border.size().y < 54.0, "{size:?} {orientation:?}");
+ refused.push((size, orientation));
+ continue;
+ };
+ let corner = Vec2::new(border.max.x, border.min.y);
+ assert_eq!(layout.outline, Aabb2 { min: corner - Vec2::new(180.0, 0.0), max: corner + Vec2::new(0.0, 54.0) });
+ for (cell, placed) in block.cells.iter().zip(&layout.cells) {
+ let [x0, y0, x1, y1] = cell.rect_mm;
+ let expected = Aabb2 { min: corner + Vec2::new(x0, y0), max: corner + Vec2::new(x1, y1) };
+ assert_eq!(placed.rect, expected, "{size:?} {orientation:?} {}", cell.name);
+ let lines = inside(cell, corner);
+ let label_at = Vec2::new(lines.min.x + 1.0, lines.max.y - 3.5);
+ assert!(placed.label_at.is_some_and(|at| at.dist(label_at) < 1e-9), "{}", cell.name);
+ let value_box = Aabb2 { min: lines.min + Vec2::new(1.0, 1.0), max: Vec2::new(lines.max.x - 1.0, lines.max.y - 4.5) };
+ assert!(near(placed.value_box, value_box), "{}", cell.name);
+ }
+ }
+ }
+ }
+ assert_eq!(refused, [(PaperSize::A5, Orientation::Portrait); 2]);
+}
+
+/// The plan's line counts for the two wrapped cells at Liberation Sans' pitch (2355/1409 of the cap
+/// height): two lines of 3.5 mm for the legal owner, three of 2.5 mm for the general tolerances.
+#[test]
+fn the_wrapped_cells_hold_the_lines_the_plan_gives_them() {
+ let block = block();
+ let layout = block.layout(&iso(PaperSize::A3, Orientation::Landscape)).unwrap();
+ for (name, lines) in [("legal_owner", 2), ("general_tolerances", 3)] {
+ let i = block.cells.iter().position(|c| c.name == name).unwrap();
+ let text = text_of(&block.cells[i]);
+ let pitch = text.cap_mm * 2355.0 / 1409.0;
+ let place = |n| place_lines(layout.cells[i].value_box, n, text.cap_mm, pitch, text.align, text.fit.wrap).unwrap();
+ // From the value box's top, 59.15 mm up the sheet: under the 0.7 mm outline's inner edge.
+ let (at, warning) = place(lines);
+ assert!(at.dist(Vec2::new(layout.cells[i].value_box.min.x, 59.15 - text.cap_mm)) < 1e-9 && warning.is_none(), "{name}: {at:?}");
+ assert_eq!(place(lines + 1).1, Some(Warning::Height), "{name}");
+ }
+}
+
+#[test]
+fn hostile_definitions_are_refused() {
+ let a3 = iso(PaperSize::A3, Orientation::Landscape);
+ let with = |change: &dyn Fn(&mut TitleBlock)| {
+ let mut block = block();
+ change(&mut block);
+ block
+ };
+ let named = |name: &'static str| move |b: &mut TitleBlock| b.cells[0].name = name.into();
+ let at = |rect_mm: [f64; 4]| move |b: &mut TitleBlock| b.cells[0].rect_mm = rect_mm;
+ let label_cap = |cap_mm: f64| move |b: &mut TitleBlock| b.cells[0].label = Some(Label { text: "Title".into(), cap_mm });
+ let label_text = |text: String| move |b: &mut TitleBlock| b.cells[0].label = Some(Label { text: text.clone(), cap_mm: 2.5 });
+ let value_cap = |cap_mm: f64| move |b: &mut TitleBlock| b.cells[0].kind = text(cap_mm, HAlign::Left, Fit::default(), vec![]);
+ let mut cases: Vec<(TitleBlock, &str)> = Vec::new();
+ for side in [0.999, 1000.001, 0.0, -180.0, f64::NAN, f64::INFINITY] {
+ cases.push((with(&|b| b.size_mm.x = side), "each side of a title block is 1 to 1000 mm"));
+ cases.push((with(&|b| b.size_mm.y = side), "each side of a title block is 1 to 1000 mm"));
+ }
+ for line in [0.0, -0.7, 10.000_001, f64::NAN, f64::INFINITY] {
+ cases.push((with(&|b| b.outline_line_mm = line), "a title block's lines are above 0 and at most 10 mm wide"));
+ cases.push((with(&|b| b.cell_line_mm = line), "a title block's lines are above 0 and at most 10 mm wide"));
+ }
+ let (longest, too_long): (&'static str, &'static str) = ("a".repeat(64).leak(), "a".repeat(65).leak());
+ for name in ["", "Title", "title_Block", "1st", "title-block", "title block", "_title", "titlé", too_long] {
+ cases.push((with(&named(name)), "a cell's name is snake case and at most 64 characters"));
+ }
+ cases.push((with(&|b| b.cells[1].name = "title".into()), "no two cells have the same name"));
+ for rect_mm in [
+ [-180.0, 0.0, 0.001, 14.0],
+ [-180.0, -0.001, -68.0, 14.0],
+ [-180.001, 0.0, -68.0, 14.0],
+ [-180.0, 40.0, -68.0, 54.001],
+ [-68.0, 0.0, -68.0, 14.0],
+ [-180.0, 14.0, -68.0, 0.0],
+ [f64::NAN, 0.0, -68.0, 14.0],
+ [-180.0, 0.0, -68.0, f64::INFINITY],
+ ] {
+ cases.push((with(&at(rect_mm)), "a cell lies inside its block"));
+ }
+ // The identification number reaching 1 mm into the title, a copy of the title, a cell inside the
+ // material cell.
+ cases.push((with(&|b| b.cells[1].rect_mm = [-69.0, 0.0, 0.0, 14.0]), "no two cells overlap"));
+ cases.push((with(&|b| b.cells.push(Cell { name: "copy".into(), ..b.cells[0].clone() })), "no two cells overlap"));
+ cases.push((
+ with(&|b| b.cells.push(Cell { name: "inner".into(), rect_mm: [-170.0, 26.0, -150.0, 32.0], ..b.cells[0].clone() })),
+ "no two cells overlap",
+ ));
+ for cap in [0.0, -2.5, f64::NAN, f64::INFINITY] {
+ cases.push((with(&label_cap(cap)), "a label's cap height is finite and above 0"));
+ }
+ for text in ["Title\nblock".to_string(), "\t".into(), "a".repeat(4097)] {
+ cases.push((with(&label_text(text)), "a label is one line of at most 4096 bytes"));
+ }
+ // A 14 mm cell under a 12 mm label, a 2 mm wide cell, a symbol under a label filling its cell:
+ // the projection cell is 19.475 mm high inside its lines, so a label of 16.475 leaves no room.
+ cases.push((with(&label_cap(12.0)), "a cell has room for its value below its label"));
+ cases.push((
+ with(&|b| b.cells[11].label = Some(Label { text: "Projection".into(), cap_mm: 16.475 + 1e-9 })),
+ "a cell has room for its value below its label",
+ ));
+ cases.push((with(&at([-180.0, 0.0, -178.0, 14.0])), "a cell has room for its value below its label"));
+ cases.push((
+ with(&|b| b.cells[11].label = Some(Label { text: "Projection".into(), cap_mm: 17.0 })),
+ "a cell has room for its value below its label",
+ ));
+ // The title's value box is 7.975 mm high inside its lines. A line filling it has its descenders
+ // 2.39 mm below the box, past the 1 mm padding; the most it holds centred is 9.975 / 1.6 mm, its
+ // descenders (3/10 of it) then on the outline's inner edge.
+ let title_most = 9.975 / 1.6;
+ for cap in [0.0, -5.0, 7.975, title_most + 1e-6, f64::NAN, f64::INFINITY] {
+ cases.push((with(&value_cap(cap)), "a value's cap height is above 0 and one line of it fits its value box"));
+ }
+ // The cell content's own rule, under this module's name.
+ cases.push((
+ with(&|b| b.cells[0].kind = text(5.0, HAlign::Left, Fit::default(), vec![Part::Text(String::new()); 65])),
+ "a cell has at most 64 parts",
+ ));
+ let control = vec![Part::Text("a\u{0}".into())];
+ cases.push((
+ with(&|b| b.cells[0].kind = text(5.0, HAlign::Left, Fit::default(), control.clone())),
+ "a cell's text has no control character but a line break",
+ ));
+ let many = |n: usize| {
+ let cell = |i: usize| Cell {
+ name: format!("c{i}"),
+ rect_mm: [-10.0 * (i + 1) as f64, 0.0, -10.0 * i as f64, 10.0],
+ label: None,
+ kind: text(1.0, HAlign::Left, Fit::default(), vec![]),
+ };
+ TitleBlock { size_mm: Vec2::new(1000.0, 10.0), outline_line_mm: 0.7, cell_line_mm: 0.35, cells: (0..n).map(cell).collect() }
+ };
+ cases.push((many(MAX_CELLS + 1), "a title block has at most 64 cells"));
+ for (block, message) in cases {
+ assert_eq!(block.validate(), Err(Invalid(message)), "{block:?}");
+ assert_eq!(block.layout(&a3), Err(Invalid(message)), "{block:?}");
+ }
+ // And their limits are accepted.
+ let accepted = [
+ many(MAX_CELLS),
+ TitleBlock { size_mm: Vec2::new(1.0, 1.0), cells: vec![], ..block() },
+ TitleBlock { size_mm: Vec2::new(1000.0, 1000.0), cells: vec![], ..block() },
+ // The widest outline on its own: the default's text doesn't fit inside a 10 mm line.
+ TitleBlock { outline_line_mm: 10.0, cells: vec![], ..block() },
+ with(&|b| b.cell_line_mm = 1e-9),
+ with(&named("a")),
+ with(&named("title_2")),
+ with(&named(longest)),
+ with(&value_cap(title_most - 1e-6)),
+ with(&|b| b.cells[11].label = Some(Label { text: "Projection".into(), cap_mm: 16.475 - 1e-9 })),
+ with(&label_text("a".repeat(4096))),
+ with(&|b| b.cells[0].label = None),
+ ];
+ for block in accepted {
+ block.validate().unwrap();
+ }
+}
+
+#[test]
+fn a_block_round_trips_through_json_and_unknown_fields_are_refused() {
+ let block = block();
+ let value = serde_json::to_value(&block).unwrap();
+ assert_eq!(value["size_mm"], json!([180.0, 54.0]));
+ assert_eq!((value["outline_line_mm"].clone(), value["cell_line_mm"].clone()), (json!(0.7), json!(0.35)));
+ assert_eq!(
+ value["cells"][5],
+ json!({
+ "name": "sheet",
+ "rect_mm": [-31.0, 14.0, 0.0, 24.0],
+ "label": {"text": "Sheet", "cap_mm": 2.5},
+ "kind": {"text": {
+ "content": [
+ {"field": {"source": "sheet", "key": "number", "format": {"unit": null, "decimals": null}}},
+ {"text": "/"},
+ {"field": {"source": "sheet", "key": "count", "format": {"unit": null, "decimals": null}}}
+ ],
+ "cap_mm": 3.5,
+ "align": "centre",
+ "fit": {"max_chars": 9, "wide_max_chars": null, "wrap": false}
+ }}
+ })
+ );
+ assert_eq!(value["cells"][11]["kind"], json!("projection_symbol"));
+ let read = |v: serde_json::Value| serde_json::from_value::<TitleBlock>(v);
+ assert_eq!(read(value.clone()).unwrap(), block);
+ // Not given: no label, left-aligned, nothing to fit.
+ let mut plain = value.clone();
+ for key in ["align", "fit"] {
+ plain["cells"][0]["kind"]["text"].as_object_mut().unwrap().remove(key);
+ }
+ plain["cells"][0].as_object_mut().unwrap().remove("label");
+ let plain = read(plain).unwrap();
+ assert_eq!((plain.cells[0].label.clone(), text_of(&plain.cells[0]).align, text_of(&plain.cells[0]).fit), (None, HAlign::Left, Fit::default()));
+ for at in ["", "/cells/0", "/cells/0/label", "/cells/0/kind/text", "/cells/0/kind/text/fit"] {
+ let mut v = value.clone();
+ v.pointer_mut(at).unwrap()["scale"] = json!(1);
+ assert!(read(v).is_err(), "an unknown field at {at:?}");
+ }
+ for (at, bad) in [
+ ("/cells/11/kind", json!("logo")),
+ ("/cells/11/kind", json!("projection")),
+ ("/cells/11/kind", json!({"projection_symbol": {"angle": "third"}})),
+ ("/cells/11/kind", json!({"kind": "projection_symbol"})),
+ ("/cells/0/rect_mm", json!([-180.0, 0.0, -68.0])),
+ ("/cells/0/rect_mm", json!({"x0": -180.0})),
+ ("/cells/0/name", json!(1)),
+ ("/size_mm", json!([180.0])),
+ ] {
+ let mut v = value.clone();
+ *v.pointer_mut(at).unwrap() = bad.clone();
+ assert!(read(v).is_err(), "{at}: {bad}");
+ }
+}
+
+#[test]
+fn a_drawing_border_that_isnt_finite_holds_no_block() {
+ let block = block();
+ let a3 = iso(PaperSize::A3, Orientation::Landscape);
+ for drawing_border in [Aabb2::EMPTY, rect(410.0, 10.0, 10.0, 287.0), rect(f64::NAN, 10.0, 410.0, 287.0), rect(10.0, 10.0, f64::INFINITY, 287.0)] {
+ let sheet = SheetLayout { drawing_border, ..a3.clone() };
+ assert_eq!(block.layout(&sheet), Err(Invalid("a title block fits inside the drawing border")), "{drawing_border:?}");
+ }
+}
+
+/// Random changes to the default's numbers, hostile ones among them: a definition is accepted or
+/// refused without panicking, and an accepted one placed on a sheet it fits (any standard size,
+/// either way, with or without the filing margin, any drawing border line) keeps every cell inside
+/// the outline, apart from the others, with its label and value box inside it, and every value box
+/// padded from the drawing border's line.
+#[test]
+fn fuzzed_definitions_never_panic_and_an_accepted_one_lays_out_inside_its_outline() {
+ const NUMBERS: [f64; 9] = [0.0, -0.0, 1e-9, 1e5, -1e5, 1000.0, f64::NAN, f64::INFINITY, f64::NEG_INFINITY];
+ let mut rng = Lcg(0x7b1c);
+ let (mut accepted, mut laid_out) = (0, 0);
+ for _ in 0..4000 {
+ let mut block = block();
+ for _ in 0..1 + (rng.unit() * 3.0) as usize {
+ let i = (rng.unit() * 12.0) as usize % 12;
+ let n = if rng.unit() < 0.3 { NUMBERS[(rng.unit() * 9.0) as usize % 9] } else { (rng.unit() - 0.5) * 20.0 };
+ let cell = &mut block.cells[i];
+ match (rng.unit() * 8.0) as usize {
+ 0 => block.size_mm.x += n,
+ 1 => block.size_mm.y = n,
+ 2 => block.outline_line_mm = n,
+ 3 => {
+ if let CellKind::Text(text) = &mut cell.kind {
+ text.cap_mm += n;
+ }
+ }
+ 4 => cell.label = Some(Label { text: "x".into(), cap_mm: n }),
+ k => cell.rect_mm[(k + i) % 4] += n,
+ }
+ }
+ if block.validate().is_err() {
+ continue;
+ }
+ accepted += 1;
+ let size = PaperSize::ALL[(rng.unit() * PaperSize::ALL.len() as f64) as usize % PaperSize::ALL.len()];
+ let orientation = if rng.unit() < 0.5 { Orientation::Landscape } else { Orientation::Portrait };
+ let sheet = if rng.unit() < 0.5 { iso(size, orientation) } else { filing(size, orientation) };
+ let line_mm = [0.25, 0.7, 2.0, 5.0, 10.0][(rng.unit() * 5.0) as usize % 5];
+ let sheet = SheetLayout { drawing_border_line_mm: line_mm, ..sheet };
+ let Ok(layout) = block.layout(&sheet) else { continue };
+ laid_out += 1;
+ let outline = layout.outline.inflated(1e-9);
+ let clear = sheet.drawing_border.inflated(-line_mm / 2.0 - PADDING_MM + 1e-9);
+ for (i, (cell, placed)) in block.cells.iter().zip(&layout.cells).enumerate() {
+ assert!(outline.contains(placed.rect.min) && outline.contains(placed.rect.max), "{} {:?}", cell.name, placed.rect);
+ assert!(layout.cells.iter().take(i).all(|other| !overlap(other.rect, placed.rect)), "{}", cell.name);
+ let inside = placed.rect.inflated(1e-9);
+ assert!(inside.contains(placed.value_box.min) && inside.contains(placed.value_box.max), "{}", cell.name);
+ let room = placed.value_box.size();
+ assert!(room.x > 0.0 && room.y > 0.0 && clear.contains(placed.value_box.min) && clear.contains(placed.value_box.max), "{}", cell.name);
+ if let Some(at) = placed.label_at {
+ assert!(inside.contains(at), "{}", cell.name);
+ }
+ if let CellKind::Text(text) = &cell.kind {
+ let (_, warning) = place_lines(placed.value_box, 1, text.cap_mm, text.cap_mm * 1.6, text.align, false).unwrap();
+ assert_eq!(warning, None, "{}", cell.name);
+ }
+ }
+ }
+ // Fewer lay out than accepted: about two in five meet a 5 or 10 mm border line, which leaves most blocks no room.
+ assert!(accepted > 400 && laid_out > 200, "{accepted} accepted, {laid_out} laid out");
+}
diff --git a/crates/io/src/design.rs b/crates/io/src/design.rs
index a05d7e7f04..7c50408e21 100644
--- a/crates/io/src/design.rs
+++ b/crates/io/src/design.rs
@@ -5,8 +5,10 @@ use std::collections::{BTreeMap, BTreeSet};
use std::io::{Cursor, Read, Seek, SeekFrom, Write};
use std::sync::Arc;
+mod drawing;
mod native_cache;
mod thumbnail;
+pub use drawing::{FileKind, file_kind, read_drawing, read_drawing_file, write_drawing_container};
pub use native_cache::read_design_geometry;
pub use thumbnail::{THUMBNAIL_SIZE, read_design_thumbnail, read_design_thumbnail_file};
@@ -88,6 +90,12 @@ fn part_limit(name: &str) -> usize {
}
impl PackageWriter {
+ fn new() -> PackageWriter {
+ PackageWriter { zip: zip::ZipWriter::new(Cursor::new(Vec::new())), names: BTreeSet::new(), expanded: 0, resolved: 0 }
+ }
+ fn finish(self) -> Result<Vec<u8>> {
+ Ok(self.zip.finish().map_err(invalid)?.into_inner())
+ }
fn part(&mut self, name: &str, bytes: &[u8], compressed: bool) -> Result<()> {
if bytes.len() > part_limit(name) {
return Err(invalid("part too large"));
@@ -245,7 +253,7 @@ fn write_container(
budget: usize,
) -> Result<Vec<u8>> {
doc.render.validate().map_err(invalid)?;
- let mut writer = PackageWriter { zip: zip::ZipWriter::new(Cursor::new(Vec::new())), names: BTreeSet::new(), expanded: 0, resolved: 0 };
+ let mut writer = PackageWriter::new();
let mut features = Vec::with_capacity(doc.features.len());
for feature in &doc.features {
let replacements = match &feature.kind {
@@ -326,7 +334,7 @@ fn write_container(
if let Some(png) = thumbnail {
thumbnail::write(&mut writer, png, &metadata)?;
}
- let bytes = writer.zip.finish().map_err(invalid)?.into_inner();
+ let bytes = writer.finish()?;
if bytes.len() > MAX_DESIGN_BYTES {
return Err(invalid(format!("the design would be {} MB, over the {} MB a design file may hold", bytes.len() >> 20, MAX_DESIGN_BYTES >> 20)));
}
@@ -463,8 +471,8 @@ impl<R: Read + Seek> PackageReader<R> {
}
self.document.as_ref().filter(|d| d.len() <= limit).cloned().ok_or_else(|| invalid("metadata budget"))
}
- fn part(&mut self, name: &str) -> Result<Vec<u8>> {
- self.limited_part(name, part_limit(name))
+ fn has_part(&self, name: &str) -> bool {
+ self.zip.index_for_name(name).is_some()
}
fn limited_part(&mut self, name: &str, limit: usize) -> Result<Vec<u8>> {
let part = self.zip.by_name(name).map_err(|e| invalid(format!("required part `{name}`: {e}")))?;
@@ -654,6 +662,33 @@ pub(super) fn read(bytes: &[u8]) -> Result<Document> {
/// keeps one seekable file handle instead of buffering the complete archive. JSON continues
/// through the normal migrations.
pub fn read_design_file(path: &str, notify: Option<impl FnOnce(DesignPreview)>) -> Result<(Document, Option<solidcraft_doc::SavedModel>)> {
+ let mut source = open_regular_file(path)?;
+ if is_container_source(&mut source)? {
+ let mut reader = DesignContainerReader::new(source)?;
+ // A design with its model opens without a picture first: the model is the session.
+ let model = reader.geometry();
+ if let Some(notify) = notify
+ && model.is_none()
+ && let Ok(preview) = read_preview(&mut reader.reader)
+ {
+ notify(preview);
+ }
+ Ok((reader.read_document()?, model))
+ } else {
+ let mut bytes = Vec::new();
+ source.take(MAX_DESIGN_BYTES as u64 + 1).read_to_end(&mut bytes).map_err(invalid)?;
+ Ok((crate::read_design(&bytes)?, None))
+ }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+type FileSource = std::fs::File;
+#[cfg(target_arch = "wasm32")]
+type FileSource = Cursor<Vec<u8>>;
+
+/// A file to read: inside the folders this process may use, a regular file, and at most
+/// [`MAX_DESIGN_BYTES`], read from its start.
+fn open_regular_file(path: &str) -> Result<FileSource> {
#[cfg(not(target_arch = "wasm32"))]
let mut source = {
crate::vfs::check(path).map_err(invalid)?;
@@ -677,33 +712,24 @@ pub fn read_design_file(path: &str, notify: Option<impl FnOnce(DesignPreview)>)
return Err(invalid("file too large"));
}
source.seek(SeekFrom::Start(0)).map_err(invalid)?;
+ Ok(source)
+}
+
+/// Whether a source starts as a container does, leaving it at its start.
+fn is_container_source(source: &mut FileSource) -> Result<bool> {
let mut prefix = [0u8; 4];
+ let size = source.seek(SeekFrom::End(0)).map_err(invalid)?;
+ source.seek(SeekFrom::Start(0)).map_err(invalid)?;
if size >= 4 {
source.read_exact(&mut prefix).map_err(invalid)?;
}
source.seek(SeekFrom::Start(0)).map_err(invalid)?;
- if is_design_container(&prefix) {
- let mut reader = DesignContainerReader::new(source)?;
- // A design with its model opens without a picture first: the model is the session.
- let model = reader.geometry();
- if let Some(notify) = notify
- && model.is_none()
- && let Ok(preview) = read_preview(&mut reader.reader)
- {
- notify(preview);
- }
- Ok((reader.read_document()?, model))
- } else {
- let mut bytes = Vec::new();
- source.take(MAX_DESIGN_BYTES as u64 + 1).read_to_end(&mut bytes).map_err(invalid)?;
- Ok((crate::read_design(&bytes)?, None))
- }
+ Ok(is_design_container(&prefix))
}
fn read_document<R: Read + Seek>(reader: &mut PackageReader<R>) -> Result<Document> {
- let version: Value = serde_json::from_slice(&reader.part("container.json")?).map_err(invalid)?;
- if !matches!(version.get("format").and_then(Value::as_str), Some(VERSION | LEGACY_VERSION)) {
- return Err(invalid("unsupported container version"));
+ if drawing::container_kind(reader)? == FileKind::Drawing {
+ return Err(IoError::Invalid("this file is a SolidCraft drawing, not a design: open it as a drawing".into()));
}
let bytes = reader.document(MAX_DESIGN_BYTES)?;
check_hdr_manifest(&bytes)?;
diff --git a/crates/io/src/design/drawing.rs b/crates/io/src/design/drawing.rs
new file mode 100644
index 0000000000..1fa4de7109
--- /dev/null
+++ b/crates/io/src/design/drawing.rs
@@ -0,0 +1,113 @@
+//! Drawing files (#3890): a [`Drawing`] saved as a container or as plain JSON, like a design.
+//!
+//! A drawing container is a design container holding `drawing.json` (Deflate, as
+//! `document.json`) in place of `document.json`, and saying so in `container.json`:
+//! `{"content": "drawing", "format": "solidcraft-container/1"}`. A design's `container.json` has no
+//! `content`, as before. The container's own checks (budgets, entries, the ZIP directory) are the
+//! design container's. The plain JSON form is [`Drawing::to_json`]'s text, the same bytes each
+//! save, so a drawing can live in version control as text.
+//!
+//! A design is never read as a drawing nor a drawing as a design: [`file_kind`] tells them apart,
+//! and each reader refuses the other's file by name.
+
+use std::io::{Cursor, Read, Seek};
+
+use serde::Deserialize;
+use serde_json::{Value, json};
+use solidcraft_doc::drawing::{Drawing, MAX_DRAWING_BYTES};
+use solidcraft_doc::format::DRAWING;
+
+use super::{PackageReader, PackageWriter, VERSION, invalid, is_design_container};
+use crate::{IoError, MAX_DESIGN_BYTES, Result};
+
+/// The part a drawing container keeps its drawing in.
+const DRAWING_PART: &str = "drawing.json";
+/// What a drawing's `container.json` says it holds.
+const DRAWING_CONTENT: &str = "drawing";
+
+/// What a SolidCraft file holds.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum FileKind {
+ Design,
+ Drawing,
+}
+
+/// Which kind of file `bytes` are, from the container's `container.json` or the JSON's `format`.
+/// JSON that isn't a drawing's counts as a design, which the design reader then checks.
+pub fn file_kind(bytes: &[u8]) -> Result<FileKind> {
+ if is_design_container(bytes) {
+ return container_kind(&mut PackageReader::new(Cursor::new(bytes))?);
+ }
+ #[derive(Deserialize)]
+ struct Format {
+ format: Option<String>,
+ }
+ let format = serde_json::from_slice::<Format>(bytes).ok().and_then(|f| f.format);
+ Ok(if format.is_some_and(|f| DRAWING.version_of(&f).is_some()) { FileKind::Drawing } else { FileKind::Design })
+}
+
+/// What a container holds, by its `container.json`: no `content` is a design.
+pub(super) fn container_kind<R: Read + Seek>(reader: &mut PackageReader<R>) -> Result<FileKind> {
+ let container: Value = serde_json::from_slice(&reader.limited_part("container.json", 4096)?).map_err(invalid)?;
+ if !matches!(container.get("format").and_then(Value::as_str), Some(super::VERSION | super::LEGACY_VERSION)) {
+ return Err(invalid("unsupported container version"));
+ }
+ match container.get("content") {
+ None => Ok(FileKind::Design),
+ Some(Value::String(content)) if content == DRAWING_CONTENT => Ok(FileKind::Drawing),
+ Some(other) => Err(invalid(format!("this build doesn't know container content {other}"))),
+ }
+}
+
+/// The drawing as a container: the same bytes for the same drawing.
+pub fn write_drawing_container(drawing: &Drawing) -> Result<Vec<u8>> {
+ let text = drawing.to_json()?;
+ let mut writer = PackageWriter::new();
+ writer.part(DRAWING_PART, text.as_bytes(), true)?;
+ let container = json!({"format": VERSION, "content": DRAWING_CONTENT});
+ writer.part("container.json", &serde_json::to_vec(&container).map_err(invalid)?, false)?;
+ writer.finish()
+}
+
+/// Read a drawing file's bytes: a container or plain JSON.
+pub fn read_drawing(bytes: &[u8]) -> Result<Drawing> {
+ if bytes.len() > MAX_DESIGN_BYTES {
+ return Err(IoError::Invalid("drawing file too large".into()));
+ }
+ if is_design_container(bytes) {
+ return read_container(Cursor::new(bytes));
+ }
+ if file_kind(bytes)? == FileKind::Design {
+ return Err(IoError::Invalid("this file is a SolidCraft design, not a drawing: open it as a design".into()));
+ }
+ let text = std::str::from_utf8(bytes).map_err(|_| IoError::Invalid("drawing file is not UTF-8 JSON".into()))?;
+ Ok(Drawing::from_json(text)?)
+}
+
+/// Read a drawing from disk (or the browser's files), a container through one seekable handle.
+pub fn read_drawing_file(path: &str) -> Result<Drawing> {
+ let mut source = super::open_regular_file(path)?;
+ if super::is_container_source(&mut source)? {
+ return read_container(source);
+ }
+ let mut bytes = Vec::new();
+ source.take(MAX_DRAWING_BYTES as u64 + 1).read_to_end(&mut bytes).map_err(invalid)?;
+ read_drawing(&bytes)
+}
+
+fn read_container<R: Read + Seek>(source: R) -> Result<Drawing> {
+ let mut reader = PackageReader::new(source)?;
+ if container_kind(&mut reader)? == FileKind::Design {
+ return Err(IoError::Invalid("this file is a SolidCraft design, not a drawing: open it as a design".into()));
+ }
+ if reader.has_part("document.json") {
+ return Err(invalid("a drawing container also holds a design's document.json"));
+ }
+ let bytes = reader.limited_part(DRAWING_PART, MAX_DRAWING_BYTES)?;
+ let text = std::str::from_utf8(&bytes).map_err(invalid)?;
+ Ok(Drawing::from_json(text)?)
+}
+
+#[cfg(test)]
+#[path = "drawing_tests.rs"]
+mod tests;
diff --git a/crates/io/src/design/drawing_tests.rs b/crates/io/src/design/drawing_tests.rs
new file mode 100644
index 0000000000..cc4ce25062
--- /dev/null
+++ b/crates/io/src/design/drawing_tests.rs
@@ -0,0 +1,155 @@
+use std::collections::BTreeMap;
+use std::io::Write;
+
+use solidcraft_doc::Document;
+use solidcraft_doc::drawing::Source;
+use solidcraft_doc::ids::IdSource;
+use solidcraft_geom::drawing_sheet::{self, DrawingBorderProfile, Orientation, PaperSize};
+
+use super::*;
+use crate::{is_drawing_path, read_design, write_design, write_design_container};
+
+/// A drawing of two designs on one A3 sheet.
+fn drawing() -> Drawing {
+ let mut ids = IdSource::seeded(3890);
+ let a3 = drawing_sheet::Sheet::standard(PaperSize::A3, Orientation::Landscape);
+ let mut d = Drawing::new("Plate assembly", "en-GB", "Assembly", a3, Some(DrawingBorderProfile::iso()), &mut ids).unwrap();
+ for path in ["plate.sc", "../parts/bolt.sc"] {
+ let id = d.allocate_id(&mut ids).unwrap();
+ d.sources.push(Source { id, path: path.into() });
+ }
+ d
+}
+
+/// A container's parts by name.
+fn parts(bytes: &[u8]) -> BTreeMap<String, Vec<u8>> {
+ let mut zip = zip::ZipArchive::new(Cursor::new(bytes)).unwrap();
+ (0..zip.len())
+ .map(|i| {
+ let mut entry = zip.by_index(i).unwrap();
+ let mut bytes = Vec::new();
+ entry.read_to_end(&mut bytes).unwrap();
+ (entry.name().unwrap().into_owned(), bytes)
+ })
+ .collect()
+}
+
+/// A container written part by part, as a hostile or older tool might.
+fn container(parts: &[(&str, &[u8])]) -> Vec<u8> {
+ let mut writer = PackageWriter::new();
+ for (name, bytes) in parts {
+ writer.part(name, bytes, true).unwrap();
+ }
+ writer.finish().unwrap()
+}
+
+fn error(result: Result<impl std::fmt::Debug>) -> String {
+ result.err().map(|e| e.to_string()).unwrap_or_else(|| panic!("accepted"))
+}
+
+/// A drawing round-trips through both forms, each giving the same bytes every save; the
+/// container holds `container.json` and `drawing.json`, and no `document.json`.
+#[test]
+fn a_drawing_round_trips_through_both_forms_byte_for_byte() {
+ let d = drawing();
+ let bytes = write_drawing_container(&d).unwrap();
+ assert_eq!(read_drawing(&bytes).unwrap(), d);
+ assert_eq!(write_drawing_container(&read_drawing(&bytes).unwrap()).unwrap(), bytes, "save, open, save: the same bytes");
+ let inside = parts(&bytes);
+ assert_eq!(inside.keys().map(String::as_str).collect::<Vec<_>>(), ["container.json", "drawing.json"]);
+ assert_eq!(inside["container.json"], br#"{"content":"drawing","format":"solidcraft-container/1"}"#);
+ let json = d.to_json().unwrap();
+ assert_eq!(inside["drawing.json"], json.as_bytes(), "the container holds the plain form's text");
+ let again = read_drawing(json.as_bytes()).unwrap();
+ assert_eq!((again.to_json().unwrap(), &again), (json, &d));
+}
+
+/// Each file is the kind it says: a design container's `container.json` has no `content`, a
+/// drawing's says `drawing`, and plain JSON is a drawing when its format is one.
+#[test]
+fn file_kind_tells_designs_and_drawings_apart() {
+ let doc = Document::new("Plate");
+ let design = write_design_container(&doc).unwrap();
+ assert_eq!(parts(&design)["container.json"], br#"{"format":"solidcraft-container/1"}"#, "a design's container is as it was");
+ let d = drawing();
+ let cases = [
+ (design, FileKind::Design),
+ (write_design(&doc), FileKind::Design),
+ (write_drawing_container(&d).unwrap(), FileKind::Drawing),
+ (d.to_json().unwrap().into_bytes(), FileKind::Drawing),
+ (b"{\"format\": \"solidcraft-drawing/1\"}".to_vec(), FileKind::Drawing),
+ (b"{\"format\": \"solidcraft/1\"}".to_vec(), FileKind::Design),
+ (b"not json".to_vec(), FileKind::Design),
+ ];
+ for (bytes, kind) in cases {
+ assert_eq!(file_kind(&bytes).unwrap(), kind, "{}", String::from_utf8_lossy(&bytes[..bytes.len().min(40)]));
+ }
+}
+
+/// Neither reader takes the other's file, and each says what the file is.
+#[test]
+fn a_design_is_never_read_as_a_drawing_nor_a_drawing_as_a_design() {
+ let d = drawing();
+ for bytes in [write_drawing_container(&d).unwrap(), d.to_json().unwrap().into_bytes()] {
+ assert!(error(read_design(&bytes)).contains("is a SolidCraft drawing, not a design"));
+ }
+ let doc = Document::new("Plate");
+ for bytes in [write_design_container(&doc).unwrap(), write_design(&doc)] {
+ assert!(error(read_drawing(&bytes)).contains("is a SolidCraft design, not a drawing"));
+ }
+}
+
+/// What a drawing container refuses: content this build doesn't know, a design's document beside
+/// the drawing, a missing drawing, an unknown container version, and a damaged drawing.
+#[test]
+fn a_drawing_container_refuses_what_it_cant_take() {
+ let text = drawing().to_json().unwrap();
+ let drawing_json = |content: &str| format!(r#"{{"content":{content},"format":"solidcraft-container/1"}}"#);
+ let cases: [(Vec<u8>, &str); 6] = [
+ (container(&[("container.json", drawing_json("\"sketch\"").as_bytes()), ("drawing.json", text.as_bytes())]), "container content \"sketch\""),
+ (container(&[("container.json", drawing_json("7").as_bytes()), ("drawing.json", text.as_bytes())]), "container content 7"),
+ (
+ container(&[
+ ("container.json", drawing_json("\"drawing\"").as_bytes()),
+ ("drawing.json", text.as_bytes()),
+ ("document.json", &b"{}"[..]),
+ ]),
+ "also holds a design's document.json",
+ ),
+ (container(&[("container.json", drawing_json("\"drawing\"").as_bytes())]), "required part `drawing.json`"),
+ (
+ container(&[("container.json", &br#"{"content":"drawing","format":"solidcraft-container/9"}"#[..]), ("drawing.json", text.as_bytes())]),
+ "version",
+ ),
+ (
+ container(&[("container.json", drawing_json("\"drawing\"").as_bytes()), ("drawing.json", text.replace("en-GB", "e").as_bytes())]),
+ "damaged drawing",
+ ),
+ ];
+ for (bytes, says) in cases {
+ let e = error(read_drawing(&bytes));
+ assert!(e.contains(says), "{says}: {e}");
+ }
+ assert!(error(read_design(&container(&[("container.json", drawing_json("\"sketch\"").as_bytes())]))).contains("container content"));
+}
+
+/// Drawing files: the extension, and reading one from disk in either form.
+#[cfg(not(target_arch = "wasm32"))]
+#[test]
+fn drawing_files_open_from_disk_in_either_form() {
+ // The browsers' file pickers take only ASCII letters, digits, `+` and `.`, up to 16 long.
+ assert!(crate::DRAWING_EXT.len() < 16 && crate::DRAWING_EXT.bytes().all(|b| b.is_ascii_alphanumeric()), "{}", crate::DRAWING_EXT);
+ for (path, drawing) in [("a.scdwg", true), ("A.SCDWG", true), ("a.sc", false), ("scdwg", false), ("a.dwg", false)] {
+ assert_eq!(is_drawing_path(path), drawing, "{path}");
+ }
+ let d = drawing();
+ let dir = std::env::temp_dir().join(format!("solidcraft-drawing-files-{}", std::process::id()));
+ std::fs::create_dir_all(&dir).unwrap();
+ for (name, bytes) in [("container.scdwg", write_drawing_container(&d).unwrap()), ("plain.scdwg", d.to_json().unwrap().into_bytes())] {
+ let path = dir.join(name);
+ std::fs::File::create(&path).unwrap().write_all(&bytes).unwrap();
+ assert_eq!(read_drawing_file(path.to_str().unwrap()).unwrap(), d, "{name}");
+ }
+ assert!(error(read_drawing_file(dir.to_str().unwrap())).contains("not a regular file"));
+ std::fs::remove_dir_all(&dir).unwrap();
+}
diff --git a/crates/io/src/lib.rs b/crates/io/src/lib.rs
index 2e9bdcdb4e..271046f8e6 100644
--- a/crates/io/src/lib.rs
+++ b/crates/io/src/lib.rs
@@ -14,15 +14,17 @@ mod dxf;
mod dxf_out;
pub mod formats;
pub use design::{
- DesignCompression, DesignContainerReader, DesignPreview, THUMBNAIL_SIZE, is_design_container, read_design_file, read_design_geometry,
- read_design_preview, read_design_thumbnail, read_design_thumbnail_file, write_design_container, write_design_container_with_cache,
- write_design_container_with_compression, write_design_container_with_preview, write_design_container_with_thumbnail,
+ DesignCompression, DesignContainerReader, DesignPreview, FileKind, THUMBNAIL_SIZE, file_kind, is_design_container, read_design_file,
+ read_design_geometry, read_design_preview, read_design_thumbnail, read_design_thumbnail_file, read_drawing, read_drawing_file,
+ write_design_container, write_design_container_with_cache, write_design_container_with_compression, write_design_container_with_preview,
+ write_design_container_with_thumbnail, write_drawing_container,
};
mod legacy_dir;
#[cfg(test)]
mod mutate;
mod native_cad;
pub use native_cad::{NATIVE_CAD_EXTS, is_native_cad_path, native_cad_to_step};
+pub mod paper;
pub mod safe_write;
mod sketch2d;
mod svg;
@@ -69,6 +71,14 @@ pub fn is_design_path(path: &str) -> bool {
pub fn is_design_container_path(path: &std::path::Path) -> bool {
path.extension().and_then(|e| e.to_str()).is_some_and(is_design_ext)
}
+/// Drawing file extension: a drawing is a file of its own beside the designs it draws. Short and
+/// plain, as the browsers' file pickers take only ASCII letters, digits, `+` and `.`, up to 16 long.
+pub const DRAWING_EXT: &str = "scdwg";
+
+/// Is this a drawing file name (`.scdwg`, any case)?
+pub fn is_drawing_path(path: &str) -> bool {
+ std::path::Path::new(path).extension().and_then(|e| e.to_str()).is_some_and(|e| e.eq_ignore_ascii_case(DRAWING_EXT))
+}
/// Largest design file we read.
pub const MAX_DESIGN_BYTES: usize = 256 << 20;
@@ -667,7 +677,11 @@ pub fn read_design(bytes: &[u8]) -> Result<Document> {
return design::read(bytes);
}
let s = std::str::from_utf8(bytes).map_err(|_| IoError::Invalid("design file is not UTF-8 JSON".into()))?;
- Ok(Document::from_json(s)?)
+ // Only a file that isn't a design pays for asking whether it is a drawing.
+ Document::from_json(s).map_err(|e| match file_kind(bytes) {
+ Ok(FileKind::Drawing) => IoError::Invalid("this file is a SolidCraft drawing, not a design: open it as a drawing".into()),
+ _ => e.into(),
+ })
}
/// Design file bytes.
diff --git a/crates/io/src/mutate.rs b/crates/io/src/mutate.rs
index 5fe98b6e05..10e27a12b6 100644
--- a/crates/io/src/mutate.rs
+++ b/crates/io/src/mutate.rs
@@ -525,6 +525,55 @@ outer
survives("design JSON", &mutations(&json, true, 0xde6), usize::MAX, |b| crate::read_design(b).ok().map(|d| d.features.len()));
}
+ /// A drawing, as a container and as plain JSON: every mutation gives an error or a drawing,
+ /// never a panic, and `file_kind` always answers.
+ #[test]
+ fn drawings_survive_mutation() {
+ use solidcraft_geom::drawing_sheet::{DrawingBorderProfile, Orientation, PaperSize, Sheet};
+ let mut ids = solidcraft_doc::ids::IdSource::seeded(0xd4a);
+ let a3 = Sheet::standard(PaperSize::A3, Orientation::Landscape);
+ let mut drawing = solidcraft_doc::drawing::Drawing::new("Fuzz", "en", "Sheet 1", a3, Some(DrawingBorderProfile::iso()), &mut ids).unwrap();
+ let id = drawing.allocate_id(&mut ids).unwrap();
+ drawing.sources.push(solidcraft_doc::drawing::Source { id, path: "plate.sc".into() });
+ let container = crate::write_drawing_container(&drawing).unwrap();
+ assert!(crate::read_drawing(&container).is_ok());
+ survives("drawing container", &mutations(&container, false, 0xd4b), usize::MAX, |b| {
+ let _ = crate::file_kind(b);
+ let _ = crate::read_design(b);
+ crate::read_drawing(b).ok().map(|d| d.sheets.len())
+ });
+ let json = drawing.to_json().unwrap().into_bytes();
+ assert!(crate::read_drawing(&json).is_ok());
+ survives("drawing JSON", &mutations(&json, true, 0xd4c), usize::MAX, |b| {
+ let _ = crate::file_kind(b);
+ crate::read_drawing(b).ok().map(|d| d.sheets.len())
+ });
+ }
+
+ /// A paper scene's JSON, mutated, read, prepared and written as SVG: an error or a document,
+ /// never a panic.
+ #[test]
+ fn paper_scenes_survive_mutation_into_svg() {
+ use solidcraft_geom::paper::{Group, Item, ObjectKind, Scene};
+ use solidcraft_geom::{Loop2, Region2, Seg2, Vec2};
+ let p = Vec2::new;
+ let border = Loop2::polygon(&[p(20.0, 10.0), p(410.0, 10.0), p(410.0, 287.0), p(20.0, 287.0)]);
+ let items = vec![
+ Item::Stroke { path: border.segs.clone(), closed: true, width_mm: 0.7 },
+ Item::Stroke { path: vec![Seg2::Arc { center: p(50.0, 50.0), radius: 10.0, start: 0.0, sweep: 4.0 }], closed: false, width_mm: 0.35 },
+ Item::Fill { region: Region2 { outer: border, holes: vec![] } },
+ ];
+ let scene = Scene { size_mm: p(420.0, 297.0), groups: vec![Group { object: 7, kind: ObjectKind::DrawingBorder, items }] };
+ let json = serde_json::to_vec(&scene).unwrap();
+ let write = |b: &[u8]| -> Option<usize> {
+ let scene: Scene = serde_json::from_slice(b).ok()?;
+ let prepared = scene.prepare().ok()?;
+ crate::paper::paper_svg(&prepared).ok().map(|(bytes, _)| bytes.len())
+ };
+ assert!(write(&json).is_some());
+ survives("paper scene to SVG", &mutations(&json, true, 0x5a3), usize::MAX, write);
+ }
+
/// Standard base64 (RFC 4648) of `bytes`, for a data URI.
fn base64(bytes: &[u8]) -> String {
const A: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
diff --git a/crates/io/src/paper.rs b/crates/io/src/paper.rs
new file mode 100644
index 0000000000..c4ea5b94d4
--- /dev/null
+++ b/crates/io/src/paper.rs
@@ -0,0 +1,5 @@
+//! A sheet's paper scene (`geom::paper`) in a file: SVG first (A3, #4890); DXF, PNG and PDF follow.
+
+mod svg;
+
+pub use svg::{SvgReport, paper_svg};
diff --git a/crates/io/src/paper/svg.rs b/crates/io/src/paper/svg.rs
new file mode 100644
index 0000000000..474b8c32b4
--- /dev/null
+++ b/crates/io/src/paper/svg.rs
@@ -0,0 +1,242 @@
+//! A paper scene as SVG (#4890, A3): one user unit a millimetre, the paper's size in mm, and the
+//! scene's own curves where SVG has them.
+//!
+//! - **Numbers** are whole nanometres, written as millimetres with up to six decimals: no exponent, no "-0",
+//! nothing that depends on the locale. They are also the writer's state, so a joint is written
+//! once and a closed path ends exactly on its first point.
+//! - **y is flipped** by writing the page height less y, so the file's numbers are page
+//! coordinates, with no transform. After the flip an anticlockwise arc turns the negative way,
+//! so its sweep flag is 0.
+//! - **Curves:** lines `L`, circular arcs `A` in pieces of at most a quarter turn (a half turn's
+//! centre is ill-conditioned once its ends are rounded), cubics `C`, parabolas `Q`. Ellipses,
+//! hyperbolas and Béziers above degree 3 aren't written yet (A3b): a scene with one is refused.
+//! - **Paint:** strokes `stroke-width`, with butt caps, miter joins and a miter limit of 4 on the
+//! root; fills black, even-odd. One `<path>` per item, so each stays one object in an editor.
+//! - **Groups** are `<g data-object="…" data-kind="…">`: object ids repeat and start with a digit,
+//! so they can't be XML ids. No background: the page stays transparent, as cutters want.
+//!
+//! What the grid can't express is counted, never an error: a width under half a nanometre is
+//! written as one, and a piece ending within 10 nanometres of where the path is goes straight on
+//! to the next.
+
+use std::fmt::Write;
+
+use solidcraft_geom::paper::{Item, Prepared, arc_pieces};
+use solidcraft_geom::{Region2, Seg2, Vec2};
+
+use crate::{IoError, MAX_DRAWING_BYTES, Result};
+
+/// The largest number written, in millimetres either way: far past any scene's 2e5.
+const MAX_NUMBER_MM: f64 = 9e9;
+/// Pieces ending this many grid steps or fewer from where the path is are merged (1e-5 mm).
+const SLIVER_STEPS: i64 = 10;
+
+/// What writing a scene did that the scene didn't say.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct SvgReport {
+ /// Widths under half a nanometre, written as one nanometre.
+ pub widths_snapped: usize,
+ /// Pieces too short for the nanometre grid, merged into the next.
+ pub pieces_merged: usize,
+}
+
+/// A scene's SVG document, and what writing it did.
+pub fn paper_svg(scene: &Prepared) -> Result<(Vec<u8>, SvgReport)> {
+ let mut w = Writer { out: String::new(), height: nano(scene.size_mm().y)?, report: SvgReport::default(), at: (0, 0), first: (0, 0) };
+ let (width, height) = (number(nano(scene.size_mm().x)?), number(w.height));
+ w.out.push_str("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
+ let _ = writeln!(
+ w.out,
+ "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"{width}mm\" height=\"{height}mm\" viewBox=\"0 0 {width} {height}\" \
+ fill=\"none\" stroke=\"#000\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\" stroke-miterlimit=\"4\">"
+ );
+ for group in scene.groups() {
+ let kind = serde_json::to_value(group.kind).ok().and_then(|v| v.as_str().map(str::to_string)).unwrap_or_default();
+ let _ = writeln!(w.out, "<g data-object=\"{}\" data-kind=\"{kind}\">", group.object);
+ for item in &group.items {
+ match item {
+ Item::Stroke { path, closed, width_mm } => w.stroke(path, *closed, *width_mm)?,
+ Item::Fill { region } => w.fill(region)?,
+ }
+ if w.out.len() > MAX_DRAWING_BYTES {
+ return Err(IoError::Invalid(format!("the SVG would be over {} MiB", MAX_DRAWING_BYTES >> 20)));
+ }
+ }
+ w.out.push_str("</g>\n");
+ }
+ w.out.push_str("</svg>\n");
+ Ok((w.out.into_bytes(), w.report))
+}
+
+/// A value in millimetres as whole nanometres.
+fn nano(v: f64) -> Result<i64> {
+ let n = (v * 1e6).round();
+ if n.abs() <= MAX_NUMBER_MM * 1e6 { Ok(n as i64) } else { Err(IoError::Invalid("a number too large (or not a number) for the SVG".into())) }
+}
+
+/// Nanometres written as millimetres onto `out`: the integer part, then up to six decimals
+/// without trailing zeros.
+fn push_number(out: &mut String, n: i64) {
+ let (sign, n) = if n < 0 { ("-", n.unsigned_abs()) } else { ("", n.unsigned_abs()) };
+ let (whole, mut part, mut digits) = (n / 1_000_000, n % 1_000_000, 6);
+ let _ = write!(out, "{sign}{whole}");
+ if part != 0 {
+ while part % 10 == 0 {
+ (part, digits) = (part / 10, digits - 1);
+ }
+ let _ = write!(out, ".{part:0digits$}");
+ }
+}
+
+/// [`push_number`] as its own text, for the numbers written once per document or arc.
+fn number(n: i64) -> String {
+ let mut text = String::new();
+ push_number(&mut text, n);
+ text
+}
+
+struct Writer {
+ out: String,
+ /// The page height, in nanometres: y is written as this less y.
+ height: i64,
+ report: SvgReport,
+ /// Where the path is, and where its subpath started, on the grid.
+ at: (i64, i64),
+ first: (i64, i64),
+}
+
+impl Writer {
+ /// A scene point on the page's grid.
+ fn grid(&self, p: Vec2) -> Result<(i64, i64)> {
+ Ok((nano(p.x)?, self.height - nano(p.y)?))
+ }
+
+ fn point(&mut self, (x, y): (i64, i64)) {
+ push_number(&mut self.out, x);
+ self.out.push(' ');
+ push_number(&mut self.out, y);
+ }
+
+ /// Starts a subpath at `p`.
+ fn move_to(&mut self, p: Vec2) -> Result<()> {
+ let at = self.grid(p)?;
+ self.out.push('M');
+ self.point(at);
+ (self.at, self.first) = (at, at);
+ Ok(())
+ }
+
+ /// Whether a piece ending at `end` is too short to write: it is merged into the next. A path's
+ /// last piece (`keep`) has no next, so it is written unless it has no length: an open path
+ /// ends where it ends, a closed one on its first point exactly.
+ fn merged(&mut self, end: (i64, i64), keep: bool) -> bool {
+ if keep {
+ return end == self.at;
+ }
+ let (dx, dy) = (end.0 - self.at.0, end.1 - self.at.1);
+ let short = dx.abs() <= SLIVER_STEPS && dy.abs() <= SLIVER_STEPS && dx * dx + dy * dy <= SLIVER_STEPS * SLIVER_STEPS;
+ if short {
+ self.report.pieces_merged += 1;
+ }
+ short
+ }
+
+ /// One piece, from where the path is: `closing` makes its end the subpath's first point, and
+ /// `keep` marks the path's last piece ([`Writer::merged`]).
+ fn piece(&mut self, seg: &Seg2, closing: bool, keep: bool) -> Result<()> {
+ let end = if closing { self.first } else { self.grid(seg.end())? };
+ match *seg {
+ Seg2::Line { .. } => {
+ if !self.merged(end, keep) {
+ self.out.push('L');
+ self.point(end);
+ self.at = end;
+ }
+ }
+ Seg2::Arc { center, radius, start, sweep } => {
+ let r = number(nano(radius)?);
+ let flag = u8::from(sweep < 0.0);
+ let mut ends = arc_pieces(center, radius, start, sweep).peekable();
+ while let Some(p) = ends.next() {
+ let final_piece = ends.peek().is_none();
+ let to = if final_piece { end } else { self.grid(p)? };
+ if !self.merged(to, keep && final_piece) {
+ let _ = write!(self.out, "A{r} {r} 0 0 {flag} ");
+ self.point(to);
+ self.at = to;
+ }
+ }
+ }
+ Seg2::Cubic { p1, p2, .. } => {
+ let (c1, c2) = (self.grid(p1)?, self.grid(p2)?);
+ self.out.push('C');
+ self.point(c1);
+ self.out.push(' ');
+ self.point(c2);
+ self.out.push(' ');
+ self.point(end);
+ self.at = end;
+ }
+ Seg2::Conic { apex, w, .. } if (w - 1.0).abs() <= 1e-12 => {
+ let c = self.grid(apex)?;
+ self.out.push('Q');
+ self.point(c);
+ self.out.push(' ');
+ self.point(end);
+ self.at = end;
+ }
+ Seg2::Conic { .. } | Seg2::Bezier { .. } => {
+ return Err(IoError::Invalid("not supported yet: SVG of ellipses, hyperbolas and Béziers above degree 3 (#4890, A3b)".into()));
+ }
+ }
+ Ok(())
+ }
+
+ /// A path's pieces after its `M`: a closed one ends exactly on its first point, a line back to
+ /// it as `Z`.
+ fn pieces(&mut self, path: &[Seg2], closed: bool) -> Result<()> {
+ let Some((last, body)) = path.split_last() else { return Ok(()) };
+ for seg in body {
+ self.piece(seg, false, false)?;
+ }
+ if !closed {
+ return self.piece(last, false, true);
+ }
+ if !matches!(last, Seg2::Line { .. }) {
+ self.piece(last, true, true)?;
+ }
+ self.out.push('Z');
+ Ok(())
+ }
+
+ fn stroke(&mut self, path: &[Seg2], closed: bool, width_mm: f64) -> Result<()> {
+ let Some(first) = path.first() else { return Ok(()) };
+ let mut width = nano(width_mm)?;
+ if width == 0 {
+ width = 1;
+ self.report.widths_snapped += 1;
+ }
+ self.out.push_str("<path stroke-width=\"");
+ push_number(&mut self.out, width);
+ self.out.push_str("\" d=\"");
+ self.move_to(first.start())?;
+ self.pieces(path, closed)?;
+ self.out.push_str("\"/>\n");
+ Ok(())
+ }
+
+ fn fill(&mut self, region: &Region2) -> Result<()> {
+ self.out.push_str("<path fill=\"#000\" stroke=\"none\" fill-rule=\"evenodd\" d=\"");
+ for l in region.loops() {
+ let Some(first) = l.segs.first() else { continue };
+ self.move_to(first.start())?;
+ self.pieces(&l.segs, true)?;
+ }
+ self.out.push_str("\"/>\n");
+ Ok(())
+ }
+}
+
+#[cfg(test)]
+#[path = "svg_tests.rs"]
+mod tests;
diff --git a/crates/io/src/paper/svg_tests.rs b/crates/io/src/paper/svg_tests.rs
new file mode 100644
index 0000000000..6f16b9b259
--- /dev/null
+++ b/crates/io/src/paper/svg_tests.rs
@@ -0,0 +1,165 @@
+use std::f64::consts::{FRAC_PI_2, PI, TAU};
+
+use solidcraft_geom::paper::{Group, ObjectKind, Scene};
+use solidcraft_geom::{Loop2, Region2};
+
+use super::*;
+use crate::{Geom2, read_svg};
+
+fn p(x: f64, y: f64) -> Vec2 {
+ Vec2::new(x, y)
+}
+
+fn line(a: Vec2, b: Vec2) -> Seg2 {
+ Seg2::Line { a, b }
+}
+
+fn stroke(path: Vec<Seg2>, closed: bool, width_mm: f64) -> Item {
+ Item::Stroke { path, closed, width_mm }
+}
+
+/// Anticlockwise from `min`.
+fn rectangle(min: Vec2, max: Vec2) -> Loop2 {
+ Loop2::polygon(&[min, p(max.x, min.y), max, p(min.x, max.y)])
+}
+
+/// An A3 landscape sheet with one object's items.
+fn sheet(items: Vec<Item>) -> Scene {
+ Scene { size_mm: p(420.0, 297.0), groups: vec![Group { object: 1, kind: ObjectKind::DrawingBorder, items }] }
+}
+
+fn svg(scene: &Scene) -> (String, SvgReport) {
+ let (bytes, report) = paper_svg(&scene.prepare().unwrap()).unwrap();
+ (String::from_utf8(bytes).unwrap(), report)
+}
+
+/// The `d` of the document's first path.
+fn first_d(scene: &Scene) -> String {
+ let (text, _) = svg(scene);
+ let start = text.find(" d=\"").unwrap() + 4;
+ text[start..].split('"').next().unwrap().to_string()
+}
+
+fn arc(center: Vec2, radius: f64, start: f64, sweep: f64) -> Seg2 {
+ Seg2::Arc { center, radius, start, sweep }
+}
+
+/// The plan's A3 sheet, the whole document: a drawing border closed by `Z`, two trimming fills.
+#[test]
+fn an_a3_drawing_border_is_this_document() {
+ let scene = sheet(vec![
+ stroke(rectangle(p(20.0, 10.0), p(410.0, 287.0)).segs, true, 0.7),
+ Item::Fill { region: Region2 { outer: rectangle(p(0.0, 0.0), p(10.0, 5.0)), holes: vec![] } },
+ Item::Fill { region: Region2 { outer: rectangle(p(0.0, 0.0), p(5.0, 10.0)), holes: vec![] } },
+ ]);
+ let (text, report) = svg(&scene);
+ let expected = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n\
+ <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"420mm\" height=\"297mm\" viewBox=\"0 0 420 297\" fill=\"none\" stroke=\"#000\" \
+ stroke-linecap=\"butt\" stroke-linejoin=\"miter\" stroke-miterlimit=\"4\">\n\
+ <g data-object=\"1\" data-kind=\"drawing_border\">\n\
+ <path stroke-width=\"0.7\" d=\"M20 287L410 287L410 10L20 10Z\"/>\n\
+ <path fill=\"#000\" stroke=\"none\" fill-rule=\"evenodd\" d=\"M0 297L10 297L10 292L0 292Z\"/>\n\
+ <path fill=\"#000\" stroke=\"none\" fill-rule=\"evenodd\" d=\"M0 297L5 297L5 287L0 287Z\"/>\n\
+ </g>\n\
+ </svg>\n";
+ assert_eq!(text, expected);
+ assert_eq!(report, SvgReport::default());
+ assert_eq!(svg(&scene).0, text, "the same scene gives the same bytes");
+}
+
+/// Arcs: anticlockwise on paper is sweep flag 0 after the flip, clockwise 1; at most a quarter turn
+/// a piece, so a 270° arc is three and a whole turn four, large-arc never 1.
+#[test]
+fn arcs_are_written_in_quarter_turns_with_the_flipped_sweep() {
+ let c = p(50.0, 50.0);
+ let open = |seg: Seg2| sheet(vec![stroke(vec![seg], false, 0.35)]);
+ assert_eq!(first_d(&open(arc(c, 10.0, 0.0, FRAC_PI_2))), "M60 247A10 10 0 0 0 50 237");
+ assert_eq!(first_d(&open(arc(c, 10.0, 0.0, 1.5 * PI))), "M60 247A10 10 0 0 0 50 237A10 10 0 0 0 40 247A10 10 0 0 0 50 257");
+ assert_eq!(first_d(&open(arc(c, 10.0, FRAC_PI_2, -FRAC_PI_2))), "M50 237A10 10 0 0 1 60 247", "clockwise: sweep flag 1");
+ let circle = first_d(&sheet(vec![stroke(vec![arc(c, 10.0, 0.0, TAU)], true, 0.35)]));
+ assert_eq!(circle, "M60 247A10 10 0 0 0 50 237A10 10 0 0 0 40 247A10 10 0 0 0 50 257A10 10 0 0 0 60 247Z");
+ let halves = first_d(&sheet(vec![stroke(Loop2::circle(c, 10.0).segs, true, 0.35)]));
+ assert_eq!(halves, circle, "a circle of two halves is the same four quarters");
+ // Just over a quarter is two pieces; a quarter and a hair (the 1e-9 margin) is one.
+ assert_eq!(first_d(&open(arc(c, 10.0, 0.0, FRAC_PI_2 + 1e-12))).matches('A').count(), 1);
+ assert_eq!(first_d(&open(arc(c, 10.0, 0.0, FRAC_PI_2 + 1e-6))).matches('A').count(), 2);
+}
+
+/// Cubics as `C`, parabolas as `Q`; ellipses, hyperbolas and higher Béziers refused until A3b.
+#[test]
+fn cubics_and_parabolas_are_written_and_other_conics_refused() {
+ let cubic = Seg2::Cubic { p0: p(0.0, 0.0), p1: p(10.0, 20.0), p2: p(30.0, 20.0), p3: p(40.0, 0.0) };
+ assert_eq!(first_d(&sheet(vec![stroke(vec![cubic], false, 0.25)])), "M0 297C10 277 30 277 40 297");
+ let parabola = Seg2::Conic { a: p(0.0, 0.0), apex: p(10.0, 10.0), b: p(20.0, 0.0), w: 1.0 };
+ assert_eq!(first_d(&sheet(vec![stroke(vec![parabola], false, 0.25)])), "M0 297Q10 287 20 297");
+ for w in [0.5, 2.0] {
+ let conic = Seg2::Conic { a: p(0.0, 0.0), apex: p(10.0, 10.0), b: p(20.0, 0.0), w };
+ let scene = sheet(vec![stroke(vec![conic], false, 0.25)]);
+ let e = paper_svg(&scene.prepare().unwrap()).err().map(|e| e.to_string()).unwrap();
+ assert!(e.contains("not supported yet"), "{w}: {e}");
+ }
+}
+
+/// Numbers are whole nanometres: no exponent, no "-0", trailing zeros trimmed; a width under half
+/// a nanometre is written as one and reported.
+#[test]
+fn numbers_are_whole_nanometres() {
+ for (n, text) in [(0, "0"), (1, "0.000001"), (-1, "-0.000001"), (1_500_000, "1.5"), (-420_000_000, "-420"), (123_456_789, "123.456789")] {
+ assert_eq!(number(n), text);
+ }
+ assert_eq!((nano(-0.0).unwrap(), nano(4e-7).unwrap(), nano(6e-7).unwrap()), (0, 0, 1));
+ assert!(nano(f64::NAN).is_err() && nano(1e10).is_err());
+ let thin = sheet(vec![stroke(vec![line(p(0.0, 0.0), p(1.0, 0.0))], false, 1e-9)]);
+ let (text, report) = svg(&thin);
+ assert!(text.contains("stroke-width=\"0.000001\""), "{text}");
+ assert_eq!(report.widths_snapped, 1);
+}
+
+/// A closed path ends exactly on its first point, even when its end and start round apart; a
+/// sliver of a piece is merged into the next and reported; an open path's last piece is kept
+/// however short, since nothing follows it.
+#[test]
+fn joints_and_closure_are_exact_on_the_grid() {
+ // The start rounds to 1 nanometre, the end (2e-10 away) to 0: the last curve ends on the start.
+ let (s, e) = (p(5e-7 + 1e-10, 0.0), p(5e-7 - 1e-10, 0.0));
+ let path =
+ vec![line(s, p(10.0, 0.0)), line(p(10.0, 0.0), p(10.0, 10.0)), Seg2::Cubic { p0: p(10.0, 10.0), p1: p(5.0, 10.0), p2: p(0.0, 5.0), p3: e }];
+ let d = first_d(&sheet(vec![stroke(path, true, 0.35)]));
+ assert_eq!(d, "M0.000001 297L10 297L10 287C5 287 0 292 0.000001 297Z");
+ // A 1e-9 mm line between two lines: merged, the path straight on to the next point.
+ let path = vec![line(p(0.0, 0.0), p(10.0, 0.0)), line(p(10.0, 0.0), p(10.0, 1e-9)), line(p(10.0, 1e-9), p(15.0, 8.66))];
+ let (text, report) = svg(&sheet(vec![stroke(path, false, 0.35)]));
+ assert!(text.contains("d=\"M0 297L10 297L15 288.34\""), "{text}");
+ assert_eq!(report.pieces_merged, 1);
+ // A 5 nanometre last piece of an open path stays; one that rounds to no length doesn't.
+ let path = vec![line(p(0.0, 0.0), p(10.0, 0.0)), line(p(10.0, 0.0), p(10.000005, 0.0))];
+ let (text, report) = svg(&sheet(vec![stroke(path, false, 0.35)]));
+ assert!(text.contains("d=\"M0 297L10 297L10.000005 297\""), "{text}");
+ assert_eq!(report.pieces_merged, 0);
+ let path = vec![line(p(0.0, 0.0), p(10.0, 0.0)), line(p(10.0, 0.0), p(10.0000001, 0.0))];
+ assert_eq!(first_d(&sheet(vec![stroke(path, false, 0.35)])), "M0 297L10 297");
+ // The same for an arc's last quarter: a 5 nanometre arc ending an open path is written.
+ let path = vec![line(p(0.0, 0.0), p(10.0, 0.0)), arc(p(10.0, 1.0), 1.0, -FRAC_PI_2, 5e-6)];
+ assert!(first_d(&sheet(vec![stroke(path, false, 0.35)])).starts_with("M0 297L10 297A1 1 0 0 0 10.000005 297"));
+}
+
+/// Our own SVG reader takes the file back: in millimetres, lines exactly (these have at most six
+/// decimals), circular arcs as arcs. The reader's root transform puts the page's top at 0, so its
+/// y is ours less the height.
+#[test]
+fn the_svg_reader_reads_it_back() {
+ let scene = sheet(vec![
+ stroke(vec![line(p(20.0, 10.0), p(410.0, 10.0)), line(p(410.0, 10.0), p(410.0, 287.0))], false, 0.7),
+ stroke(vec![arc(p(50.0, 50.0), 10.0, 0.0, FRAC_PI_2)], false, 0.35),
+ ]);
+ let (text, _) = svg(&scene);
+ let read = read_svg(&text).unwrap();
+ let up = |v: Vec2| p(v.x, v.y + 297.0);
+ let lines: Vec<(Vec2, Vec2)> = read.iter().filter_map(|g| if let Geom2::Line(a, b) = g { Some((up(*a), up(*b))) } else { None }).collect();
+ assert_eq!(lines, [(p(20.0, 10.0), p(410.0, 10.0)), (p(410.0, 10.0), p(410.0, 287.0))]);
+ let arcs: Vec<(Vec2, Vec2, Vec2)> =
+ read.iter().filter_map(|g| if let Geom2::Arc { c, a, b } = g { Some((up(*c), up(*a), up(*b))) } else { None }).collect();
+ assert_eq!(arcs.len(), 1, "{read:?}");
+ let (c, a, b) = arcs[0];
+ assert!(c.dist(p(50.0, 50.0)) < 3e-6 && a.dist(p(60.0, 50.0)) < 3e-6 && b.dist(p(50.0, 60.0)) < 3e-6, "{:?}", arcs[0]);
+}
diff --git a/docs/book/src/guide/assemblies.md b/docs/book/src/guide/assemblies.md
index 1f3420ef86..5053876745 100644
--- a/docs/book/src/guide/assemblies.md
+++ b/docs/book/src/guide/assemblies.md
@@ -398,7 +398,7 @@ revision, other tools' data under a reverse-DNS key (the same rules as the desig
properties), and free text properties such as a material grade or a finish. Every occurrence of
the component shares them, Paste New copies them, and they are saved with the component.
`component.metadata {component}` reads them and
-`component.metadata.set {component, part_number?, description?, revision?, values?, properties?}`
+`component.metadata.set {component, part_number?, description?, revision?, bom_type?, values?, properties?}`
changes them in one undo step (an empty value removes a field). The root component is the
design itself: its properties are `document.metadata`'s. Standard parts (`parts.insert`) get a
part number from their standard and size (`ISO 4762 M6x20`, or a bearing's designation) and a
@@ -420,8 +420,23 @@ description; **Change Part Size** renumbers them, keeping a field you changed yo
rows. `total_occurrences` counts the children too, so it is the same either way.
- `component` lists one subassembly's parts instead of the design's.
+A component's **bill of materials type** (`bom_type`, a part property set with
+`component.metadata.set {component, bom_type}`) decides how it counts in the assemblies it is
+placed in. Without one it is `normal`.
+
+| Type | For | In the assembly it is placed in |
+|---|---|---|
+| `normal` | Something you make | A row of its own; every occurrence adds to its quantity |
+| `phantom` | Something just to group (a fastener set) | No row: what it holds counts as if it were placed there directly, in the same rows as the same parts placed there |
+| `reference` | Something to use as a reference (a fixture shown for context) | Counted nowhere, and nothing inside it is counted either |
+| `purchased` | Something you buy (a gearbox) | One row; nothing inside it is counted or listed |
+| `inseparable` | Something made as one piece: welded, glued, riveted and so on (a welded frame) | One row; in parts only, the purchased parts inside it are listed too, and the rest of what it holds is listed in its own bill of materials |
+
+Two components with the same part number share a row only when their types agree. A
+component's own bill of materials (`component`) lists what it holds whatever its type.
+
Rows are sorted by part number (rows without one come last) and hold `item`, `part_number`,
-`description`, `revision`, `count`, `definition` (the component names), `components` (their ids)
+`description`, `revision`, `bom_type`, `count`, `definition` (the component names), `components` (their ids)
and `properties`, with `total_occurrences` beside them. `path` writes them to a `.csv` file
(the columns item, part_number, description, revision, count and definition, every field
quoted; children follow their row) or a `.json` file. The window lists the same rows, switches
diff --git a/docs/book/src/reference/glossary.md b/docs/book/src/reference/glossary.md
index 1295cb27b0..377e31cc9f 100644
--- a/docs/book/src/reference/glossary.md
+++ b/docs/book/src/reference/glossary.md
@@ -46,6 +46,43 @@ An appearance sets colour and surface finish only. It has no effect on mass or s
- **Elsewhere:** appearance, visual material, colour.
- **For translators:** not the physical material.
+### bill of materials
+
+The list of the components placed in a design or in one component, with the quantity of each.
+
+It lists every part at any depth, or only the direct children. Each component's *bill of
+materials type* decides whether it has a row and whether what it holds is counted.
+
+- **In SolidCraft:** `assembly.bom` ("Bill of Materials") and its window on the INSPECT panel;
+ each row's `item`, `part_number` and `count`; a component's `metadata` and `properties`
+ design-file keys, which `component.metadata.set` changes.
+- **Don't use:** BOM in labels; parts list (for the bill of materials itself).
+- **Elsewhere:** bill of materials, BOM, parts list.
+- **For translators:** not a parts list on a drawing, which is one table that shows it.
+
+### bill of materials type
+
+The rule that decides whether a component has a row in a bill of materials, and whether what it
+holds is counted there.
+
+There are five:
+
+- *normal*, something you make: a row; each occurrence adds one to its quantity.
+- *phantom*, something just to group: no row; what it holds counts where it is placed.
+- *reference*, something to use as a reference: no row, and nothing inside it counts.
+- *purchased*, something you buy: one row; nothing inside it is counted or listed.
+- *inseparable*, something made as one piece (welded, glued, riveted and so on): one row; of
+ what it holds, only the purchased components are listed, and only in a list of every part.
+
+- **In SolidCraft:** the `bom_type` part property, which `component.metadata.set` changes and
+ `component.metadata` reads; the `bom_type` of each `assembly.bom` row.
+- **Don't use:** BOM structure, item type, kind; made (for *normal*: it reads as "already
+ made").
+- **Elsewhere:** BOM structure, BOM type.
+- **For translators:** *normal* here is not the sketch line type, a direction or the display
+ quality (see *Words with more than one meaning*); *reference* is not a construction plane;
+ *phantom* is not a hidden or see-through display.
+
### body
One connected solid or surface shape that features create and change.
@@ -365,6 +402,7 @@ share a catalogue entry. Each meaning below gets its own term and, in time, its
| Normal | a sketch entity that isn't a construction entity | normal (line type) | the sketch palette's line type |
| | the direction perpendicular to a surface | normal (direction) | the ruled surface's Normal mode |
| | the middle display quality | normal (quality) | `ui.display_quality_normal` |
+| | a component with a row of its own in a bill of materials | normal (bill of materials type) | `bom_type` |
| Quantity | the number of pattern instances | count | the pattern dialogs' Quantity rows, `ui.quantity` |
| | what the motion plot shows: value, velocity or acceleration | plotted quantity | the motion study's Quantity row, `motion.plot_quantity` |
| Reference | an edge a hole or cylinder keeps its distance from | *reference edge* | `references` of `solid.hole` and `solid.cylinder`, `ui.reference_1` |
diff --git a/docs/drawing-hlr.md b/docs/drawing-hlr.md
new file mode 100644
index 0000000000..3e68470d5c
--- /dev/null
+++ b/docs/drawing-hlr.md
@@ -0,0 +1,198 @@
+# Hidden lines (W06a)
+
+This is the geometry core of Drawing package W06 from the [published plan][plan] in
+[#860][rfc]: [#2455][issue] / [PR #2457][pr]. It turns the subset that the W05a
+investigation ([#2105][w05-issue], [draft #2106][w05-pr], [findings][findings])
+showed to be ready into code: exact orthographic hidden lines for placed bodies whose
+faces are planes, cylinders, cones, spheres or tori.
+
+The code is `crates/geom/src/hlr` (layer L0). It reads the neutral `geom::brep`
+records, uses no kernel or UI types, returns errors instead of panicking and builds for
+`wasm32-unknown-unknown`. It does not register commands, create views, extract bodies
+from the kernel or draw sections. The read-only kernel adapter follows the W02
+extraction contract; until then callers build `Brep` records themselves.
+
+## Using it
+
+```text
+prepare(&Brep, &Options) -> Result<Prepared, HlrError> once per body
+hidden_lines(&[Prepared], &[Placement], &View, &Options, &cancel) -> Result<Drawing, HlrError>
+```
+
+- `prepare` checks the body (`Brep::validate`), recognises each face's surface, builds
+ its trim and classifies each edge as sharp, tangent or seam. `Prepared::report` says
+ what it found: surfaces and curves by kind, tangent and seam edges, faces whose trim is
+ unsupported, freeform faces and the largest boundary chord error.
+- A `Placement` puts a prepared body in the scene: `world = rotation * local +
+ translation`, the rotation given by its columns. Several placements may share one
+ prepared body. A placement that is not a proper rotation (a mirror, a scale) is refused
+ with `HlrError::Invalid`.
+- `View::new(direction_of_sight, up)` is an orthographic view. Screen coordinates are
+ `(p . x, p . y)` in millimetres, with `x = direction x up` normalised and `y = x x
+ direction`.
+- `cancel` is polled during the work; when it returns true the call ends with
+ `HlrError::Cancelled`. `prepare_cancellable(&Brep, &Options, &cancel)` is `prepare` with
+ such a callback, polled between edges, faces and surface comparisons.
+
+The `Drawing` holds one `Line` per drawable edge and per silhouette curve of each
+placement, in order of placement. A line names its `placement` and `source` (`Edge { edge, tangent }`
+or `Silhouette { face }`) and is split into `pieces`. Each `Piece` has:
+
+| Field | Meaning |
+| --- | --- |
+| `t` | Parameter interval on the source curve. |
+| `visibility` | `Visible`, `Hidden` or `Uncertain`. |
+| `covered` | Another piece already draws the same projected curve here; draw only uncovered pieces. |
+| `geometry` | The piece in screen coordinates as `Seg2` segments. |
+| `accuracy` | `CurveAccuracy` of `geometry` (the [W01a vocabulary](drawing-geometry.md)). |
+
+`Drawing::unsupported` lists the faces whose silhouettes were not drawn and why;
+`Drawing::stats` counts curves, crossings, pieces, rays and uncertain pieces, with phase
+timings where the platform has a clock (zero on `wasm32-unknown-unknown`).
+
+## What is exact
+
+| Source | Geometry | Accuracy |
+| --- | --- | --- |
+| Line edges; cylinder and cone silhouette rulings | one `Seg2::Line` | `Analytic` |
+| Circle and ellipse edges; sphere silhouettes; torus silhouettes seen along the axis | `Seg2::Conic` arcs of at most 90 degrees | `Analytic` |
+| Spline and intersection edges | chords between exact points, halved until each piece's control hull is within the sag target | `Sampled` (a bound from that hull) |
+| Torus silhouettes in other views | chords between traced points, halved to 1e-7 of the torus's size | `Sampled` (measured deviation) |
+
+An orthographic projection is affine, so a circle projects to an ellipse, which a
+rational quadratic arc represents exactly. Chords are refined until their sag on screen
+is at most 1e-7 of the scene size. A fitted edge record also carries its own bound, and
+the visibility work allows for it.
+
+Surfaces are recognised whether they are stored as analytic records, as revolutions of
+lines and circles or as spline patches (to 1e-9 relative; a patch whose control points lie
+in one plane is that plane). A spline curve or patch is taken for a circle, quadric or torus
+only when it lies on it at enough points of every knot span to make the check exact for its
+degree, with its largest distance there, scaled by how far apart its weights are, within
+the tolerance: weights near zero cannot hide a swerve, and widely spread weights mean chords.
+A recognised patch is trimmed and intersected in its own analytic chart. Faces that lie on one surface (a sphere
+stored as two hemispheres, a cylinder split in two) share their silhouettes: the edges
+between them are seams and are not drawn, and a silhouette running along such a seam is
+one curve. A face joins such a set only when the first face's surface passes through its
+own points to rounding (1e-13 of its size); recognition alone groups surfaces more loosely,
+and such faces keep silhouettes of their own.
+
+## Visibility
+
+Projected curves are split where they cross or touch, found on a screen grid and
+refined on the exact curves. Each piece is classified by rays toward the viewer against
+every trimmed face: closed forms for planes and quadrics, a sampled quartic for tori.
+A ray that grazes a face, meets one within its boundary tolerance or meets another body
+right at its start makes the piece `Uncertain`; nothing is guessed.
+
+Coincident curves (an edge and a silhouette on top of each other, two touching bodies)
+follow the W05a policy: visible wins and duplicates are marked `covered`. The tolerance
+comes from the curves' own accuracy (chord sag and fit bounds) plus a rounding allowance
+of 1e-7 mm and 1e-9 of the scene size, never from the scene size alone, so small parts in
+large scenes keep their detail.
+
+`prepare` moves each body to its own centre, and the work is done in a frame centred on
+the scene and shifted back at the end, so coordinates stay small: a part 1e7 mm from the
+origin, whether placed there or modelled there, is classified as at the origin.
+
+## Freeform faces
+
+Faces that are not planes, cylinders, cones, spheres or tori are freeform. By default
+they are listed in `Drawing::unsupported` with the reason `freeform face`, their
+silhouettes are not drawn, and a piece whose ray meets one is `Uncertain`, never
+`Hidden`. Without its silhouettes nothing marks where such a face's outline crosses a curve,
+so curves are cut at the face's screen box and every piece inside the box that can reach
+behind its nearest point (bounded by the curve's control points, not by samples) is
+`Uncertain` too, the face's own edges included (faces left out for an unsupported trim
+likewise). With `Options::freeform` set their silhouettes are contoured and their ray
+tests use seeded Newton iterations: slower, `Sampled`, and subject to the misses listed
+in the W05a findings.
+
+## Limits
+
+- `Options::max_tracks` (curves) and `Options::max_rays` bound the work, as do internal
+ caps: crossing grid entries (50 million), crossing candidate pairs (500 million, counted
+ before the search, so no set of pairs met grows with them), crossings (50 million) and
+ the surface comparisons that group a body's faces (50 million). Exceeding one returns
+ `HlrError::Budget`.
+- `Options::trim_samples` is 1 to `MAX_TRIM_SAMPLES` (4096), and every coordinate of a
+ placed body at most `MAX_COORDINATE` (1e12 mm, the bound `geom::section` and
+ `geom::brep` put on stored numbers); otherwise the call returns `HlrError::Invalid`.
+- `Options::tangent_edges` (default on) draws edges between tangent faces, flagged
+ `tangent: true`; drafting policy for them is W17.
+- Tolerances are relative to the faces and the scene. They are meant for faces up to
+ about 10 m across and features down to about 1e-3 mm. A spline patch only a sliver wide
+ next to its radii (a few millionths of them) cannot be told from its neighbours' surfaces
+ reliably and is reported as freeform. Distinct surfaces that
+ recognition takes for one (closer than 1e-9 of their size or position, a nearly flat
+ cone's far apex included) share the own-face margin of 1e-6 of the face's size when a
+ ray leaves one of them.
+- Not in this slice: parallel per-curve work and the shared work limits of
+ `geom::section`, the kernel adapter (after W02), perspective, section regions (W03),
+ views and commands (W07), and mirrored placements. Of the records the kernel now saves,
+ planes through three points (`PlaneThrough`) are drawn as planes; a body with a procedural
+ `SurfaceIntersection` curve or a `PlacedRevolution` surface (whose placement may scale it
+ unevenly) is refused by `prepare` with `HlrError::Unsupported` until the adapter handles
+ them.
+
+## Fixtures
+
+`crates/geom/src/hlr_tests.rs` builds bodies from records and checks analytic positions
+and intervals:
+
+- a cube in an isometric view hides its three back edges; a box in front hides the
+ middle of an edge over exactly the covered interval;
+- a cylinder's silhouette rulings are exact lines, including one along the seam; a cone
+ frustum seen from the front has exact rulings and draws each edge-on circle once;
+- a sphere's outline is exact conic arcs at its radius in three views;
+- a disc bounded by a rational circle with unevenly spaced knots, with a knot span narrower
+ than rounding, or with a parameterisation that races through its first turn is drawn as
+ arcs turning the full 360 degrees; splines off their circle between evenly spaced samples
+ or inside such a narrow span are drawn as chords; exact arcs that turn almost all of
+ their 358 degrees in the first hundredth of their parameter, or several radians in a
+ knot span of 1e-6 or 1e-11, keep the turn of every piece;
+- a torus stored as two halves, seen face on, is drawn at both equators, one silhouette
+ each; an edge under it is hidden over exactly the intervals the tube covers; seen
+ obliquely its outline spans R + r on both sides with a deviation under 1e-3 mm;
+- cone frusta and narrow cone sectors a hair off one axis or with axes 3e-7 rad apart, and
+ spherical caps through one circle with centres 5e-7 mm apart, keep their own outlines;
+- a cylinder 1e5 and 1e7 mm from the origin draws as at the origin; a cone trimmed to its
+ tip 1 mm below the apex hides nothing above it;
+- a freeform patch is reported and makes the edges it covers uncertain, or hidden when
+ freeform faces are enabled; a flat spline patch hides them for certain; a long edge behind
+ a freeform tube is uncertain where the tube may cover it and visible elsewhere, and so is
+ a sloping edge that only dips behind a freeform patch near its end, while one that leaves
+ the patch's box below its level but crosses the box above it stays visible;
+- a curve that swerves 2.9 mm off its circle where its weight is 1e-12, and a nearly straight
+ cubic 0.002 mm off a circle of radius 1e7, are drawn as chords; an edge whose depth dips
+ behind a freeform patch between its samples is uncertain there, and so is an arc seen
+ along its plane whose projection folds back under a freeform patch between two samples,
+ and the edge of a freeform sheet that curls back over it 0.005 mm above;
+- a torus patch stored as a rational spline is recognised and draws its outer equator as an
+ exact arc, and one with a bump in a knot span 0.002 of its parameters wide is not taken for
+ a torus; a big circle passing under a thin freeform tube in a coarse scene is uncertain
+ there;
+- two strips of a torus 0.0003 rad wide keep their 0.006 mm of outline;
+- two touching boxes draw each shared edge once;
+- a box whose top plane record stands one rounding (or 1e-11 of 100 mm) off its edges still
+ hides its back edges, and so does a 0.001 mm cube 1e7 mm out whose top plane is one step
+ above its edges; a plate's sixteen holes each hide the same part of their bottom circle;
+ eight coaxial cylinders seen along their axis show one circle; 300 boxes apart on screen
+ are each drawn as the first one; an arc that bulges across a line 1 mm off its chord still
+ crosses it twice; the trim's chord grid agrees with a scan of every chord; surface groups
+ agree with comparing every pair of faces, and preparing can be cancelled;
+- mirrored placements, bad body indices and bad views are refused; cancellation and
+ budgets return errors;
+- a box stored with planes through three points draws the same bits as one with
+ axis-stored planes; placed revolutions and procedural intersection curves are refused as
+ not supported yet;
+- torus ray roots for thin, large and nearly tangent cases, and torus silhouettes near
+ the axis direction.
+
+[rfc]: https://github.com/tangency-labs/solidcraft/issues/860
+[plan]: https://github.com/tangency-labs/solidcraft/issues/860#issuecomment-6234779815
+[findings]: https://github.com/tangency-labs/solidcraft/issues/860#issuecomment-6243691483
+[issue]: https://github.com/tangency-labs/solidcraft/issues/2455
+[pr]: https://github.com/tangency-labs/solidcraft/pull/2457
+[w05-issue]: https://github.com/tangency-labs/solidcraft/issues/2105
+[w05-pr]: https://github.com/tangency-labs/solidcraft/pull/2106
diff --git a/docs/oracle.md b/docs/oracle.md
index 86c2edd5d2..5becc8cf02 100644
--- a/docs/oracle.md
+++ b/docs/oracle.md
@@ -9,7 +9,9 @@ Where the expected values come from (the **Source** column):
No expected value comes from a commercial CAD product.
-**83 / 83 cases pass**; sources: 62 analytic, 21 freecad. 0 known failure(s) tracked in issues; 0 case(s) without expected values yet.
+**90 / 90 cases pass**; sources: 69 analytic, 21 freecad. 0 known failure(s) tracked in issues; 0 case(s) without expected values yet.
+
+**Validation note:** Case 95's analytic centre-of-mass reference was corrected after the above successful run. Its previous pass status is historical and requires a new oracle replay against the corrected reference.
| Case | Source | Result | Surface distance mm (max / mean) | Method | Notes |
|---|---|---|---|---|---|
@@ -29,13 +31,13 @@ No expected value comes from a commercial CAD product.
| 14-combine-cut | analytic | pass | | box [-25,25]^2x[-20,0] minus sphere r=15 at the origin (lower hemisphere removed): V = abc - 2/3 pi r^3, hemisphere centroid z = -3r/8; A = 2(ab+bc+ca) - pi r^2 + 2 pi r^2 | |
| 15-combine-intersect | analytic | pass | | cube [-20,20]^3 intersect sphere R=25: sphere minus 6 disjoint caps of height h=5 (caps cannot overlap: two would need x^2+y^2 > 800 > R^2); V = 4/3 pi R^3 - 6 pi h^2 (3R-h)/3, A = 4 pi R^2 - 6 * 2 pi R h + 6 pi (R^2-20^2) | |
| 16-sweep | analytic | pass | | circle r=3 swept along line 30 (+Z) + tangent R20 quarter arc + line 30 (+X): two cylinders + quarter torus (Pappus: V = pi r^2 R theta, A = 2 pi r R theta; torus centroid at rho = (R^2 + r^2/4)/R * sin(theta/2)/(theta/2) from the bend axis along the bisector) + 2 end disks | |
-| 17-loft | freecad 1.1.4 | pass | 0.013 / 0.0019 (worst at -7.9, -10.8, 31.2) | FreeCAD (OpenCASCADE) build of recipe.json by tools/freecad-oracle/build.py: Part.makeLoft | |
+| 17-loft | freecad 1.1.4 | pass | 0.013 / 0.0017 (worst at 8.7, -6.7, 37.5) | FreeCAD (OpenCASCADE) build of recipe.json by tools/freecad-oracle/build.py: Part.makeLoft | |
| 18-hole-features | analytic | pass | | plate 60x40x15 minus: counterbore (r7 x 5 deep + r4 through), countersink (90 deg cone frustum r6->r3 over 3 mm + r3 through), blind r3 hole 10 deep to the shoulder with a 118 deg cone point (height 3/tan59, centroid 1/4 up from the apex); areas: removed top/bottom disks, cylinder walls 2 pi r h, cb floor annulus, cone laterals pi r s | |
| 19-l-bracket-constrained | analytic | pass | | solved L: (0,0)-(60,0)-(60,8)-(8,8)-(8,40)-(0,40); area 60x8 + 8x32, extruded 20: V = A2 h, A = 2 A2 + perimeter*h, centroid of the two rectangles | |
| 20-slot-constrained | analytic | pass | | obround: arc centres (0,0) and (40,0), R6, tangent horizontal lines y=+-6: A2 = 2rL + pi r^2, V = A2 h, A = 2 A2 + perimeter (2L + 2 pi r) h | |
| 21-draft | analytic | pass | | 40x40x30 box, 5 deg draft hinged on the bottom (z=0), pull -Z: square frustum 40 -> 40 + 2*30*tan5; V = h/3 (A0 + A1 + sqrt(A0A1)), sides 4 trapezoids of slant h/cos5 | |
| 22-split-body | analytic | pass | | cylinder r20 z -30..30 split by the plane through the X axis tilted 30 deg (z = y tan30, stays within /z/<=11.6 inside the cylinder): 2 congruent halves (point symmetry), V total = pi r^2 h, A total = cylinder + 2 ellipses pi r (r/cos30) | |
-| 23-bracket-multifeature | freecad 1.1.4 | pass | 0.007 / 0.0010 (worst at 57.3, 49.3, 25.8) | FreeCAD (OpenCASCADE) build of recipe.json by tools/freecad-oracle/build.py: Part extrude, Part extrude join, Part makeFillet, Part extrude join, Part extrude cut, Part makeChamfer | |
+| 23-bracket-multifeature | freecad 1.1.4 | pass | 0.007 / 0.0010 (worst at 62.7, 48.7, 25.8) | FreeCAD (OpenCASCADE) build of recipe.json by tools/freecad-oracle/build.py: Part extrude, Part extrude join, Part makeFillet, Part extrude join, Part extrude cut, Part makeChamfer | |
| 24-user-parameters | analytic | pass | | width 60 x depth 40 x height 15 block from the origin with a centred d10 through hole: V = (wd - pi r^2) h, A = 2(wd - pi r^2) + 2(w+d)h + 2 pi r h | |
| 25-sketch-triangle | analytic | pass | | solved triangle (0,0), (50,0), P = t(cos60, sin60) with t = 25 + sqrt(150) from /P-(50,0)/ = 45 (the root nearest the drawn apex); V = (1/2 * 50 * Py) * 5, A = 2 A2 + perimeter*5, centroid = vertex mean | |
| 26-sketch-belt | analytic | pass | | belt: convex hull of circles R20 @ (0,0) and r10 @ (50,0) (external tangents, sin a = (R-r)/d) minus the d8 hole at (50,0), extruded 5 as one body; hull area = (R+r) sqrt(d^2-(R-r)^2) + R^2(pi+2a)/2 + r^2(pi-2a)/2; moments by Green's theorem over the line/arc boundary | |
@@ -43,7 +45,7 @@ No expected value comes from a commercial CAD product.
| 28-blind-pocket-fillets | freecad 1.1.4 | pass | 0.009 / 0.0015 (worst at 60.0, 15.1, 13.4) | FreeCAD (OpenCASCADE) build of recipe.json by tools/freecad-oracle/build.py: Part extrude, Part extrude cut, Part makeFillet | |
| 29-two-sided-and-partial-revolve | analytic | pass | | block [-20,20]x[-25,10]x[0,20] minus the 270 deg revolve (from +X towards +Y) of the 8x8 square r 4..12, z 12..20; the removed section is the annular sector minus the circular segment y > 10 (R^2 acos(d/R) - d sqrt(R^2-d^2), y-moment 2/3 (R^2-d^2)^1.5) that lies outside the block; sector moments (R^3-r^3)/3 (sin, 1-cos); A = box - top opening + floor - front-face notch 2 sqrt(44) x 8 + inner wall r th h + outer wall (th - pi + 2 asin(5/6)) R h + 2 end caps | |
| 30-fillet-after-shell | freecad 1.1.4 | pass | 0.008 / 0.0025 (worst at 56.3, 35.7, 3.5) | FreeCAD (OpenCASCADE) build of recipe.json by tools/freecad-oracle/build.py: Part extrude, makeThickness shell, Part makeFillet | |
-| 31-fillet-l-all-edges | freecad 1.1.4 | pass | 0.009 / 0.0018 (worst at 7.9, 38.6, 18.0) | FreeCAD (OpenCASCADE) build of recipe.json by tools/freecad-oracle/build.py: Part extrude, Part makeFillet | |
+| 31-fillet-l-all-edges | freecad 1.1.4 | pass | 0.009 / 0.0018 (worst at 6.0, 38.6, 19.9) | FreeCAD (OpenCASCADE) build of recipe.json by tools/freecad-oracle/build.py: Part extrude, Part makeFillet | |
| 32-boss-plate-fillets | analytic | pass | | plate 60x60x8 + boss (r10, z 8..23) with R3 concave base and R2 convex top fillets taken as one solid of revolution: V, z-moment and lateral area from Pappus/Green on its (r,z) profile (quarter-circle fillet arcs); plate top loses the r13 disc | |
| 33-fillet-tangent-chain | analytic | pass | | obround (R8, centres 40 apart) x 10 minus R2 fillet spandrel R^2(1-pi/4) and 1 mm chamfer triangle swept round the whole loop. Swept volumes use Pappus; Z moments account for inward-offset perimeter P(u)=P-2pi*u: fillet top-depth moment P*A*d-2pi*r^4*(19/24-pi/4), A=r^2*(1-pi/4), d=r*(10-3pi)/(3*(4-pi)); bottom chamfer Z moment P*c^3/6-pi*c^4/12; surfaces use fillet arc centroid inset r-2r/pi | |
| 34-chamfer-then-fillet | freecad 1.1.4 | pass | 0.009 / 0.0022 (worst at 38.5, 5.6, 19.9) | FreeCAD (OpenCASCADE) build of recipe.json by tools/freecad-oracle/build.py: Part extrude, Part makeChamfer, Part makeFillet | |
@@ -51,7 +53,7 @@ No expected value comes from a commercial CAD product.
| 36-corner-blend-two-radii | freecad 1.1.4 | pass | 0.012 / 0.0026 (worst at 45.4, 39.2, 26.5) | FreeCAD (OpenCASCADE) build of recipe.json by tools/freecad-oracle/build.py: Part extrude, Part makeFillet | |
| 37-pyramid-apex-blend | freecad 1.1.4 | pass | 0.020 / 0.0029 (worst at -0.0, 0.0, 28.4) | FreeCAD (OpenCASCADE) build of recipe.json by tools/freecad-oracle/build.py: Part.makeLoft, Part makeFillet | |
| 38-coincident-cylinders | analytic | pass | | union of r10 z0..30 and r10 z20..50 = cylinder r10 h50: V = pi r^2 h, A = 2 pi r h + 2 pi r^2 | |
-| 39-tee-pipe | freecad 1.1.4 | pass | 0.008 / 0.0014 (worst at -9.7, 2.4, 40.0) | FreeCAD (OpenCASCADE) build of recipe.json by tools/freecad-oracle/build.py: Part extrude, Part extrude join, Part extrude cut | |
+| 39-tee-pipe | freecad 1.1.4 | pass | 0.008 / 0.0014 (worst at 5.4, 9.1, 11.9) | FreeCAD (OpenCASCADE) build of recipe.json by tools/freecad-oracle/build.py: Part extrude, Part extrude join, Part extrude cut | |
| 40-box-sphere-torus | analytic | pass | | box 60x60x10 (z -10..0) + upper hemisphere r12 + spherical cap h2 below z=-10 (V = pi h^2(3R-h)/3, A = 2 pi R h) - lower half torus R22 r4 (Pappus: V = pi r^2/2 * 2 pi R, centroid -4r/3pi, A = pi r * 2 pi R); top loses disc r12 and annulus 18..26, bottom loses disc r sqrt(44) | faces: bottom, 4 sides, top split by the groove into an annulus (r 12..18) and the outer part, upper sphere, lower cap, torus |
| 41-tube-radial-holes | freecad 1.1.4 | pass | 0.010 / 0.0012 (worst at 1.9, 19.9, 24.8) | FreeCAD (OpenCASCADE) build of recipe.json by tools/freecad-oracle/build.py: Part extrude, Part extrude cut, pattern (tools transformed and re-applied) | |
| 42-overlapping-patterns | freecad 1.1.4 | pass | 0.009 / 0.0010 (worst at -1.0, -10.1, 2.2) | FreeCAD (OpenCASCADE) build of recipe.json by tools/freecad-oracle/build.py: Part extrude, Part extrude cut, pattern (tools transformed and re-applied), Part extrude cut, pattern (tools transformed and re-applied) | |
@@ -63,7 +65,7 @@ No expected value comes from a commercial CAD product.
| 48-pulley | analytic | pass | | revolve of the 12-segment (r,z) polygon about Z: V = 2 pi int r dA, Mz = 2 pi int r z dA, A = 2 pi int r ds (Pappus) | |
| 49-helical-sweep | analytic | pass | | true helix coil (screw motion of the axial d4 section, R20, pitch 8, 3 turns): V = turns * 2 pi R * pi a^2; lateral A = turns * 2 pi * int sqrt(r^2 + (p/2pi)^2 (dr/ds)^2) ds (periodic trapezoid, exact to round-off) + two end discs; COM z = pitch*turns/2 | |
| 50-sweep-tight-bend | analytic | pass | | tube r5 along line 20 + R5 quarter bend + line 20: V = pi r^2 L, A = 2 pi r L + 2 pi r^2 (Pappus, valid while bend radius >= r; here equal so the inner side pinches to a line); bend centroid at (R^2 + r^2/4)/R * sinc(pi/4) along the bisector | |
-| 51-loft-rect-circle-offset | freecad 1.1.4 | pass | 0.025 / 0.0030 (worst at -11.7, 15.0, 0.4) | FreeCAD (OpenCASCADE) build of recipe.json by tools/freecad-oracle/build.py: Part.makeLoft | |
+| 51-loft-rect-circle-offset | freecad 1.1.4 | pass | 0.033 / 0.0028 (worst at 17.5, -14.9, 0.5) | FreeCAD (OpenCASCADE) build of recipe.json by tools/freecad-oracle/build.py: Part.makeLoft | |
| 52-circular-pattern-fillet | analytic | pass | | disc r40 h8 + 6 x (boss r6 h10 with R2 concave base fillet as a solid of revolution, Pappus/Green on its (r,z) profile) at radius 28; disc top loses 6 discs r8 | |
| 53-path-pattern | analytic | pass | | plate 120x60x5 minus 7 through holes d6 at arc lengths k*17.875031 along the arc through (100,15),(60,45),(20,15) (centre (60,10/3), R 125/3), translated copies | |
| 54-mirror-body-fillets | analytic | pass | | prism h10 of the 60x40 rectangle with four R5 corner rounds and two d8 holes at (+-15,20): V = A h, area = 2A + perimeter*h | |
@@ -77,7 +79,7 @@ No expected value comes from a commercial CAD product.
| 62-heat-sink | analytic | pass | | base 60x50x5 + 15 fins 1.5x50x25 at x = 2 + 4k: sums of boxes; fin ends coplanar with the base ends | faces: bottom, x=0, x=60, y=0 and y=50 (each merged with the fin ends), 16 base-top strips, 15x3 fin faces |
| 63-hinge-knuckle | freecad 1.1.4 | pass | 0.008 / 0.0016 (worst at 28.0, 36.9, 4.7) | FreeCAD (OpenCASCADE) build of recipe.json by tools/freecad-oracle/build.py: Part extrude, Part extrude join, Part extrude cut | |
| 64-sketch-tangent-arc-chain | analytic | pass | | solved sketch: 80x20 rectangle whose top is 4 tangent R12 arcs on 20 mm chords alternating up/down (net area 1600); prism h3: V = A h, area = 2A + perimeter*h, Green's theorem for centroid | |
-| 65-sketch-gear-tooth | freecad 1.1.4 | pass | 0.008 / 0.0017 (worst at -6.5, 39.5, 0.0) | FreeCAD (OpenCASCADE) build of recipe.json by tools/freecad-oracle/build.py: Sketcher-solved sketch, Part extrude | |
+| 65-sketch-gear-tooth | freecad 1.1.4 | pass | 0.008 / 0.0017 (worst at 6.5, 39.5, 8.0) | FreeCAD (OpenCASCADE) build of recipe.json by tools/freecad-oracle/build.py: Sketcher-solved sketch, Part extrude | |
| 66-sketch-linkage | analytic | pass | | solved sketch: hull of circles R12 at (0,0) and R8 at (60,0) (outer tangent lines, cos a = 4/60) minus holes d12, d8 (concentric) and d4 at (30,+-4) (symmetry keeps radii equal); prism h6 | |
| 67-sm-base-flange | analytic | pass | | plate 100 x 60 x t, t = 2.5 (Steel (mm) rule), thickness along +Z: V = 100*60*t, A = 2(ab+bc+ca) | |
| 68-sm-edge-flange | analytic | pass | | extrusion along x (100) of the YZ section: base y 5..60 x t; 90 deg bend annulus R 2.5..5 about (y 5, z 5); flange y 0..2.5, z 5..20. Setback (R+t)tan45 = 5 (inside bend position, outer-face height datum: outer face of flange reaches z = 20); V = L*A_sec, A = 2 A_sec + L P_sec | trim/setback and height datum are SolidCraft's documented edge-flange conventions (sheet.rs add_flanges) |
@@ -96,6 +98,13 @@ No expected value comes from a commercial CAD product.
| 81-fillet-spline-radius | analytic | pass | | box 40x30x20 with its top front edge (y=0, z=20) rounded at a radius that is a clamped cubic B-spline in u = x/40, knots 0,0,0,0,0.25,0.6,1,1,1,1, control radii 2, 5, 1.5, 4, 1, 3 (r(0) = 2, r(40) = 3). Sections are quarter rounds; V, moments and areas integrated along the edge, exactly per knot span | |
| 82-thin-extrude-frame | analytic | pass | | square frame: the lines' 40 mm square walled 3 mm inside and 1 mm outside (mitred corners) is 42 x 42 less 34 x 34, 10 mm tall: V = (42^2 - 34^2) * 10, A = 2 (42^2 - 34^2) + 4 * 42 * 10 + 4 * 34 * 10 | |
| 83-boundary-loop-thicken | analytic | pass | | region = 10 x 10 square + half disc r 5 on its top side: A = 100 + 12.5 pi, centroid by moments (half disc's at 4r / (3 pi) above its diameter); slab of thickness 2 over it (symmetric about z = 0): V = 2A, area = 2A + 2 (30 + 5 pi) | |
+| 84-plate-two-bores | analytic | pass | | Plate L=100, W=80, T=20 mm; Bore1 at (20,20) Ø10; Bore2 at (60,50) Ø10. Box minus independently located through-cylinders: V=LWT-sum(pi*d²*T/4), area=2(LW+LT+WT)+sum(pi*d*T-pi*d²/2), mass moments from exact box minus cylinders. Shape: rectangular | |
+| 85-plate-width-100 | analytic | pass | | Plate L=100, W=100, T=20 mm; Bore1 at (20,20) Ø10; Bore2 at (60,50) Ø10. Box minus independently located through-cylinders: V=LWT-sum(pi*d²*T/4), area=2(LW+LT+WT)+sum(pi*d*T-pi*d²/2), mass moments from exact box minus cylinders. Shape: rectangular | |
+| 86-plate-first-bore-12 | analytic | pass | | Plate L=100, W=80, T=20 mm; Bore1 at (20,20) Ø12; Bore2 at (60,50) Ø10. Box minus independently located through-cylinders: V=LWT-sum(pi*d²*T/4), area=2(LW+LT+WT)+sum(pi*d*T-pi*d²/2), mass moments from exact box minus cylinders. Shape: rectangular | |
+| 87-plate-bore1-deleted | analytic | pass | | Plate L=100, W=80, T=20 mm; Bore2 at (60,50) Ø10. Box minus independently located through-cylinders: V=LWT-sum(pi*d²*T/4), area=2(LW+LT+WT)+sum(pi*d*T-pi*d²/2), mass moments from exact box minus cylinders. Shape: rectangular | |
+| 88-plate-four-bores | analytic | pass | | Plate L=150, W=80, T=10 mm; Bore1 at (15,15) Ø8; Bore2 at (135,15) Ø8; Bore3 at (15,65) Ø8; Bore4 at (135,65) Ø8. Box minus independently located through-cylinders: V=LWT-sum(pi*d²*T/4), area=2(LW+LT+WT)+sum(pi*d*T-pi*d²/2), mass moments from exact box minus cylinders. Shape: rectangular | |
+| 94-plate-four-rounded-corners | analytic | pass | | Plate L=100, W=80, T=20 mm; Bore1 at (20,20) Ø10; Bore2 at (60,50) Ø10. Box minus independently located through-cylinders: V=LWT-sum(pi*d²*T/4), area=2(LW+LT+WT)+sum(pi*d*T-pi*d²/2), mass moments from exact box minus cylinders. Shape: four exterior vertical R10 corner rounds; four corner spandrels subtract volume T*(4-pi)*R² at symmetric centroid (L/2,W/2,T/2); rounded perimeter P=2(L+W)-8R+2pi*R | |
+| 95-plate-rounded-top-chamfer | analytic | pass | | Plate L=100, W=80, T=20 mm; Bore1 at (20,20) Ø10; Bore2 at (60,50) Ø10. Box minus independently located through-cylinders: V=LWT-sum(pi*d²*T/4), area=2(LW+LT+WT)+sum(pi*d*T-pi*d²/2), mass moments from exact box minus cylinders. Shape: four exterior vertical R10 corner rounds; full upper tangent loop 2 mm chamfer; four corner spandrels subtract volume T*(4-pi)*R² at symmetric centroid (L/2,W/2,T/2); rounded perimeter P=2(L+W)-8R+2pi*R; upper tangent chamfer subtracts volume Vc=P*c²/2-pi*c³/3 at (L/2,W/2,T-(P*c³/6-pi*c⁴/12)/Vc); area from upper inset face, side strips and sqrt(2)*c*(P-pi*c) bevel surface | |
## Not covered by a reference case
diff --git a/docs/releasing.md b/docs/releasing.md
index 9ad1ceeda6..cc62e408e9 100644
--- a/docs/releasing.md
+++ b/docs/releasing.md
@@ -71,10 +71,11 @@ deployment. The stable Flatpak repository is not automatically updated with nigh
`Cargo.lock` (it changes only our own crates, never dependency versions, and needs no
network). Inspect the diff: only `version = ` lines of workspace crates should change.
SolidCraft does not currently implement `cargo xtask version set`.
-3. Fix the design format number: run `scripts/fold-format-pending.sh`. It moves the pending
- format changes (`crates/doc/src/format/pending/*.rs`) into the next `crates/doc/src/format/v<N>/`
- folder, so the release writes and reads that number for good, and does nothing when nothing
- is pending. Commit the move with the version files. (CONTRIBUTING.md, "Changing the design
+3. Fix the file format numbers: run `scripts/fold-format-pending.sh`. It moves the pending
+ format changes of designs (`crates/doc/src/format/pending/*.rs`) and of drawings
+ (`crates/doc/src/drawing/format/pending/*.rs`) into each one's next `v<N>/` folder, so the
+ release writes and reads those numbers for good, and does nothing for a family with nothing
+ pending. Commit the move with the version files. (CONTRIBUTING.md, "Changing the design
file format".)
4. Run `cargo xtask ci` and the packaging checks in `.github/workflows/packaging-lint.yml`.
Commit the version files through the normal review flow and land them on `main`.
diff --git a/scripts/fold-format-pending.sh b/scripts/fold-format-pending.sh
index ea7cfd8cbc..4608e554f1 100755
--- a/scripts/fold-format-pending.sh
+++ b/scripts/fold-format-pending.sh
@@ -1,33 +1,36 @@
#!/usr/bin/env bash
-# Release step: give the pending design-format changes their number for good.
+# Release step: give the pending file-format changes their number for good.
#
-# Moves every change in crates/doc/src/format/pending/ into crates/doc/src/format/v<N>/, where N
-# is the number development builds have been writing for them (the last folded format + 1).
-# Commit the result with the release's version bump. Nothing to do when nothing is pending.
-# See crates/doc/src/format/pending/README.md.
+# For each family of files in crates/doc/build.rs's FAMILIES (designs in crates/doc/src/format/,
+# drawings in crates/doc/src/drawing/format/), moves every change in its pending/ folder into its
+# v<N>/, where N is the number development builds have been writing for them (the family's last
+# folded format + 1). Commit the result with the release's version bump. Nothing to do for a family
+# with nothing pending. See crates/doc/src/format/pending/README.md.
set -euo pipefail
root=$(git rev-parse --show-toplevel)
-dir="$root/crates/doc/src/format"
-last=$(sed -n 's/^const HAND_WRITTEN: u32 = \([0-9]*\);/\1/p' "$root/crates/doc/build.rs")
-[ -n "$last" ] || { echo "HAND_WRITTEN not found in crates/doc/build.rs" >&2; exit 1; }
-for d in "$dir"/v*/; do
- [ -d "$d" ] || continue
- n=${d%/}
- n=${n##*/v}
- if [ "$n" -gt "$last" ]; then last=$n; fi
-done
+families=$(grep -o 'Family { folder: "[^"]*", base: [0-9]*' "$root/crates/doc/build.rs" | sed 's/.*folder: "\([^"]*\)", base: \([0-9]*\)/\1 \2/' || true)
+[ -n "$families" ] || { echo "FAMILIES not found in crates/doc/build.rs" >&2; exit 1; }
shopt -s nullglob
-pending=("$dir"/pending/*.rs)
-if [ ${#pending[@]} -eq 0 ]; then
- echo "No pending format changes: this release writes format $last."
- exit 0
-fi
-
-next=$((last + 1))
-mkdir -p "$dir/v$next"
-git -C "$root" mv "${pending[@]}" "$dir/v$next/"
-echo "Format $next is now fixed, with ${#pending[@]} change(s):"
-for f in "${pending[@]}"; do echo " ${f##*/}"; done
-echo "Commit crates/doc/src/format/ with the version bump."
+folded=0
+while read -r folder last; do
+ dir="$root/crates/doc/$folder"
+ for d in "$dir"/v*/; do
+ n=${d%/}
+ n=${n##*/v}
+ if [ "$n" -gt "$last" ]; then last=$n; fi
+ done
+ pending=("$dir"/pending/*.rs)
+ if [ ${#pending[@]} -eq 0 ]; then
+ echo "No pending format changes in $folder: this release writes format $last."
+ continue
+ fi
+ next=$((last + 1))
+ mkdir -p "$dir/v$next"
+ git -C "$root" mv "${pending[@]}" "$dir/v$next/"
+ echo "Format $next of $folder is now fixed, with ${#pending[@]} change(s):"
+ for f in "${pending[@]}"; do echo " ${f##*/}"; done
+ folded=$((folded + 1))
+done <<< "$families"
+[ "$folded" -eq 0 ] || echo "Commit crates/doc/src/ with the version bump."
diff --git a/scripts/test-format-pending.sh b/scripts/test-format-pending.sh
index 6348358670..e02f2c880a 100755
--- a/scripts/test-format-pending.sh
+++ b/scripts/test-format-pending.sh
@@ -1,6 +1,7 @@
#!/usr/bin/env bash
# Checks the design-format change files (crates/doc/src/format/): two branches that each add a
# pending change merge without a conflict, and the release fold moves both into the next number.
+# A drawing-format change (crates/doc/src/drawing/format/) folds into the drawing's own next number.
# The order they apply in and the upgrades themselves are tested in crates/doc/src/format.rs.
set -euo pipefail
@@ -8,11 +9,12 @@ root=$(git rev-parse --show-toplevel)
tmp=$(mktemp -d)
trap 'rm -rf "$tmp"' EXIT
repo="$tmp/repo"
-mkdir -p "$repo/crates/doc/src" "$repo/scripts"
+mkdir -p "$repo/crates/doc/src/drawing" "$repo/scripts"
cp -r "$root/crates/doc/src/format" "$repo/crates/doc/src/"
+cp -r "$root/crates/doc/src/drawing/format" "$repo/crates/doc/src/drawing/"
cp "$root/crates/doc/build.rs" "$repo/crates/doc/"
cp "$root/scripts/fold-format-pending.sh" "$repo/scripts/"
-rm -f "$repo"/crates/doc/src/format/pending/*.rs # start from a release: nothing pending
+rm -f "$repo"/crates/doc/src/format/pending/*.rs "$repo"/crates/doc/src/drawing/format/pending/*.rs # start from a release: nothing pending
git() { command git -C "$repo" -c user.name=test -c [email protected] "$@"; }
git init -q -b main
git add -A
@@ -20,12 +22,13 @@ git commit -qm base
change() {
git switch -q -c "$1" main
- printf '//! %s\n' "$1" > "$repo/crates/doc/src/format/pending/$1.rs"
+ printf '//! %s\n' "$1" > "$repo/crates/doc/src/${2:-format}/pending/$1.rs"
git add -A
git commit -qm "$1"
}
change b-second
change a-first
+change c-drawing drawing/format
git switch -q main
if ! tree=$(git merge-tree --write-tree a-first b-second); then
@@ -36,12 +39,18 @@ git merge -q --no-edit a-first b-second >/dev/null
listed=$(git ls-tree --name-only HEAD crates/doc/src/format/pending/ | grep '\.rs$' | sed 's#.*/##' | tr '\n' ' ')
[ "$listed" = "a-first.rs b-second.rs " ] || { echo "FAIL: merged pending changes are: $listed" >&2; exit 1; }
[ "$tree" = "$(git rev-parse HEAD^{tree})" ] || { echo "FAIL: merge-tree and merge disagree" >&2; exit 1; }
+git merge -q --no-edit c-drawing >/dev/null
before=$(ls -d "$repo"/crates/doc/src/format/v*/ 2>/dev/null | wc -l)
+drawings=$(find "$repo/crates/doc/src/drawing/format" -mindepth 1 -maxdepth 1 -type d -name 'v*' | wc -l)
(cd "$repo" && bash scripts/fold-format-pending.sh) > "$tmp/fold.log"
after=$(ls -d "$repo"/crates/doc/src/format/v*/ | sort -V | tail -1)
[ "$(ls -d "$repo"/crates/doc/src/format/v*/ | wc -l)" -eq $((before + 1)) ] || { echo "FAIL: the fold made no new version" >&2; exit 1; }
[ "$(ls "$after")" = "$(printf 'a-first.rs\nb-second.rs')" ] || { echo "FAIL: the fold moved $(ls "$after")" >&2; exit 1; }
[ -z "$(ls "$repo/crates/doc/src/format/pending/" | grep '\.rs$' || true)" ] || { echo "FAIL: pending changes left after the fold" >&2; exit 1; }
-(cd "$repo" && bash scripts/fold-format-pending.sh) | grep -q "No pending format changes" || { echo "FAIL: a second fold did something" >&2; exit 1; }
-echo "ok: pending format changes merge cleanly and fold into $(basename "$after")"
+# A drawing's formats start at 1, so its folded ones are v2/, v3/ and so on: the next is its own, never the design's.
+drawing_next="$repo/crates/doc/src/drawing/format/v$((drawings + 2))"
+[ "$(ls "$drawing_next" 2>/dev/null)" = c-drawing.rs ] || { echo "FAIL: the drawing change did not fold into ${drawing_next##*/}/" >&2; exit 1; }
+second=$(cd "$repo" && bash scripts/fold-format-pending.sh)
+grep -q "No pending format changes" <<< "$second" && ! grep -q "now fixed" <<< "$second" || { echo "FAIL: a second fold did something" >&2; exit 1; }
+echo "ok: pending format changes merge cleanly and fold into $(basename "$after"), a drawing's into ${drawing_next##*/}"
diff --git a/skills/solidcraft-file-formats/SKILL.md b/skills/solidcraft-file-formats/SKILL.md
index 200b710f76..794478c5ba 100644
--- a/skills/solidcraft-file-formats/SKILL.md
+++ b/skills/solidcraft-file-formats/SKILL.md
@@ -14,6 +14,8 @@ A design says which format it is in (`"format": "solidcraft/N"`). A change that
Two PRs that each add a change merge without a conflict. `crates/doc/src/format/pending/README.md` has an example. At release time the maintainer runs `scripts/fold-format-pending.sh`, which moves pending files into `v<N>/` for good; `scripts/test-format-pending.sh` runs in CI. Never add a file to a `v<N>/` folder afterwards. See `docs/releasing.md`.
+Drawings follow the same rules with their own numbers, from 1: a drawing-format change is ONE new file in `crates/doc/src/drawing/format/pending/` (see its `README.md`), and the same fold script moves them into `crates/doc/src/drawing/format/v<N>/`.
+
## Import
- Every import (STEP, IGES, 3MF, STL, OBJ; inserted, dropped, opened, or run as `file.insert_step`, `file.insert_mesh` or `doc.open`) becomes a new component named after the file, with the Import feature inside it. Bodies never land loose.
- Imported files are untrusted: sizes, entity counts and nesting are capped, and every kernel call is guarded (`skills/solidcraft-crash-safety/SKILL.md`). What cannot be read becomes a warning on the feature.
diff --git a/tests/oracle/84-plate-two-bores/expected.json b/tests/oracle/84-plate-two-bores/expected.json
new file mode 100644
index 0000000000..4ea97cf291
--- /dev/null
+++ b/tests/oracle/84-plate-two-bores/expected.json
@@ -0,0 +1,25 @@
+{
+ "source": "analytic",
+ "method": "Plate L=100, W=80, T=20 mm; Bore1 at (20,20) Ø10; Bore2 at (60,50) Ø10. Box minus independently located through-cylinders: V=LWT-sum(pi*d²*T/4), area=2(LW+LT+WT)+sum(pi*d*T-pi*d²/2), mass moments from exact box minus cylinders. Shape: rectangular",
+ "body_count": 1,
+ "volume_mm3": 156858.4073464102,
+ "area_mm2": 24142.477796076935,
+ "center_of_mass": [
+ 50.20028207009981,
+ 40.1001410350499,
+ 10
+ ],
+ "bbox": {
+ "min": [
+ 0,
+ 0,
+ 0
+ ],
+ "max": [
+ 100,
+ 80,
+ 20
+ ]
+ },
+ "faces": 8
+}
diff --git a/tests/oracle/84-plate-two-bores/recipe.json b/tests/oracle/84-plate-two-bores/recipe.json
new file mode 100644
index 0000000000..9c9fbbbd9c
--- /dev/null
+++ b/tests/oracle/84-plate-two-bores/recipe.json
@@ -0,0 +1,335 @@
+{
+ "id": "84-plate-two-bores",
+ "name": "Workshop plate with two independent Ø10 bores",
+ "description": "Parameterized rectangular workshop plate 100 x 80 x 20 mm with 2 independent through bores. World origin at (0,0,0).",
+ "exercises": [
+ "extrude",
+ "hole_through_all",
+ "drawing_w23_acceptance"
+ ],
+ "units": {
+ "length": "mm",
+ "angle": "deg",
+ "area": "mm2",
+ "volume": "mm3"
+ },
+ "conventions": {
+ "world": "right-handed; Z up. XY/XZ/YZ are the origin planes.",
+ "sketch_frame": "sketch-local 2D coords; world = plane.origin + x*plane.x_dir + y*plane.y_dir (origin in mm). Profile 'loops' list sketch entity ids.",
+ "point_refs": "'<id>.start' / '<id>.end' / '<id>.center' reuse (share) that existing sketch point; 'at' is its position when referenced.",
+ "extrude_direction": "positive = along sketch plane normal unless stated",
+ "selections": "selected faces/edges carry 'point': a world-space point on the face / the edge's parametric midpoint; pick the nearest face/edge to it."
+ },
+ "parameters": [
+ {
+ "name": "length",
+ "expression": "100 mm",
+ "unit": "mm"
+ },
+ {
+ "name": "width",
+ "expression": "80 mm",
+ "unit": "mm"
+ },
+ {
+ "name": "thickness",
+ "expression": "20 mm",
+ "unit": "mm"
+ },
+ {
+ "name": "bore1_d",
+ "expression": "10 mm",
+ "unit": "mm"
+ },
+ {
+ "name": "bore2_d",
+ "expression": "10 mm",
+ "unit": "mm"
+ }
+ ],
+ "features": [
+ {
+ "op": "sketch",
+ "name": "StockSketch",
+ "plane": {
+ "ref": "XY",
+ "origin": [
+ 0,
+ 0,
+ 0
+ ],
+ "x_dir": [
+ 1,
+ 0,
+ 0
+ ],
+ "y_dir": [
+ 0,
+ 1,
+ 0
+ ],
+ "normal": [
+ 0,
+ 0,
+ 1
+ ]
+ },
+ "entities": [
+ {
+ "type": "line",
+ "start": {
+ "at": [
+ 0,
+ 0
+ ]
+ },
+ "end": {
+ "at": [
+ 100,
+ 0
+ ]
+ },
+ "id": "l1"
+ },
+ {
+ "type": "line",
+ "start": {
+ "ref": "l1.end",
+ "at": [
+ 100,
+ 0
+ ]
+ },
+ "end": {
+ "at": [
+ 100,
+ 80
+ ]
+ },
+ "id": "l2"
+ },
+ {
+ "type": "line",
+ "start": {
+ "ref": "l2.end",
+ "at": [
+ 100,
+ 80
+ ]
+ },
+ "end": {
+ "at": [
+ 0,
+ 80
+ ]
+ },
+ "id": "l3"
+ },
+ {
+ "type": "line",
+ "start": {
+ "ref": "l3.end",
+ "at": [
+ 0,
+ 80
+ ]
+ },
+ "end": {
+ "ref": "l1.start",
+ "at": [
+ 0,
+ 0
+ ]
+ },
+ "id": "l4"
+ },
+ {
+ "type": "circle",
+ "id": "bore_circle_1",
+ "center": {
+ "at": [
+ 20,
+ 20
+ ]
+ },
+ "radius": 5,
+ "construction": true
+ },
+ {
+ "type": "circle",
+ "id": "bore_circle_2",
+ "center": {
+ "at": [
+ 60,
+ 50
+ ]
+ },
+ "radius": 5,
+ "construction": true
+ }
+ ],
+ "constraints": [
+ {
+ "type": "coincident",
+ "refs": [
+ "l1.start",
+ "origin"
+ ]
+ },
+ {
+ "type": "horizontal",
+ "refs": [
+ "l1"
+ ]
+ },
+ {
+ "type": "vertical",
+ "refs": [
+ "l2"
+ ]
+ },
+ {
+ "type": "horizontal",
+ "refs": [
+ "l3"
+ ]
+ },
+ {
+ "type": "vertical",
+ "refs": [
+ "l4"
+ ]
+ }
+ ],
+ "dimensions": [
+ {
+ "type": "distance",
+ "refs": [
+ "l1.start",
+ "l1.end"
+ ],
+ "value": "length",
+ "unit": "mm",
+ "orientation": "horizontal"
+ },
+ {
+ "type": "distance",
+ "refs": [
+ "l2.start",
+ "l2.end"
+ ],
+ "value": "width",
+ "unit": "mm",
+ "orientation": "vertical"
+ },
+ {
+ "type": "diameter",
+ "refs": [
+ "bore_circle_1"
+ ],
+ "value": "bore1_d",
+ "unit": "mm"
+ },
+ {
+ "type": "diameter",
+ "refs": [
+ "bore_circle_2"
+ ],
+ "value": "bore2_d",
+ "unit": "mm"
+ }
+ ]
+ },
+ {
+ "op": "extrude",
+ "name": "Stock",
+ "operation": "new",
+ "profiles": [
+ {
+ "sketch": "StockSketch",
+ "loops": [
+ {
+ "outer": true,
+ "curves": [
+ "l1",
+ "l2",
+ "l3",
+ "l4"
+ ]
+ }
+ ]
+ }
+ ],
+ "extent": {
+ "type": "distance",
+ "distance": "thickness",
+ "direction": "positive"
+ },
+ "result_bodies": [
+ "Plate"
+ ]
+ },
+ {
+ "op": "hole",
+ "name": "Bore1",
+ "hole_type": "simple",
+ "face": {
+ "type": "plane",
+ "normal_at_point_on_face": [
+ 0,
+ 0,
+ 1
+ ],
+ "plane_normal_outward": [
+ 0,
+ 0,
+ 1
+ ],
+ "point": [
+ 50,
+ 40,
+ 20
+ ]
+ },
+ "position": [
+ 20,
+ 20,
+ 20
+ ],
+ "direction": "into the material (-Z)",
+ "diameter": "bore1_d",
+ "extent": "through_all"
+ },
+ {
+ "op": "hole",
+ "name": "Bore2",
+ "hole_type": "simple",
+ "face": {
+ "type": "plane",
+ "normal_at_point_on_face": [
+ 0,
+ 0,
+ 1
+ ],
+ "plane_normal_outward": [
+ 0,
+ 0,
+ 1
+ ],
+ "point": [
+ 50,
+ 40,
+ 20
+ ]
+ },
+ "position": [
+ 60,
+ 50,
+ 20
+ ],
+ "direction": "into the material (-Z)",
+ "diameter": "bore2_d",
+ "extent": "through_all"
+ }
+ ]
+}
diff --git a/tests/oracle/85-plate-width-100/expected.json b/tests/oracle/85-plate-width-100/expected.json
new file mode 100644
index 0000000000..87834e3773
--- /dev/null
+++ b/tests/oracle/85-plate-width-100/expected.json
@@ -0,0 +1,25 @@
+{
+ "source": "analytic",
+ "method": "Plate L=100, W=100, T=20 mm; Bore1 at (20,20) Ø10; Bore2 at (60,50) Ø10. Box minus independently located through-cylinders: V=LWT-sum(pi*d²*T/4), area=2(LW+LT+WT)+sum(pi*d*T-pi*d²/2), mass moments from exact box minus cylinders. Shape: rectangular",
+ "body_count": 1,
+ "volume_mm3": 196858.4073464102,
+ "area_mm2": 28942.477796076935,
+ "center_of_mass": [
+ 50.15958641014815,
+ 50.23937961522224,
+ 10
+ ],
+ "bbox": {
+ "min": [
+ 0,
+ 0,
+ 0
+ ],
+ "max": [
+ 100,
+ 100,
+ 20
+ ]
+ },
+ "faces": 8
+}
diff --git a/tests/oracle/85-plate-width-100/recipe.json b/tests/oracle/85-plate-width-100/recipe.json
new file mode 100644
index 0000000000..c4d3a2aac2
--- /dev/null
+++ b/tests/oracle/85-plate-width-100/recipe.json
@@ -0,0 +1,335 @@
+{
+ "id": "85-plate-width-100",
+ "name": "Workshop plate after width change to 100 mm",
+ "description": "Parameterized rectangular workshop plate 100 x 100 x 20 mm with 2 independent through bores. World origin at (0,0,0).",
+ "exercises": [
+ "extrude",
+ "hole_through_all",
+ "drawing_w23_acceptance"
+ ],
+ "units": {
+ "length": "mm",
+ "angle": "deg",
+ "area": "mm2",
+ "volume": "mm3"
+ },
+ "conventions": {
+ "world": "right-handed; Z up. XY/XZ/YZ are the origin planes.",
+ "sketch_frame": "sketch-local 2D coords; world = plane.origin + x*plane.x_dir + y*plane.y_dir (origin in mm). Profile 'loops' list sketch entity ids.",
+ "point_refs": "'<id>.start' / '<id>.end' / '<id>.center' reuse (share) that existing sketch point; 'at' is its position when referenced.",
+ "extrude_direction": "positive = along sketch plane normal unless stated",
+ "selections": "selected faces/edges carry 'point': a world-space point on the face / the edge's parametric midpoint; pick the nearest face/edge to it."
+ },
+ "parameters": [
+ {
+ "name": "length",
+ "expression": "100 mm",
+ "unit": "mm"
+ },
+ {
+ "name": "width",
+ "expression": "100 mm",
+ "unit": "mm"
+ },
+ {
+ "name": "thickness",
+ "expression": "20 mm",
+ "unit": "mm"
+ },
+ {
+ "name": "bore1_d",
+ "expression": "10 mm",
+ "unit": "mm"
+ },
+ {
+ "name": "bore2_d",
+ "expression": "10 mm",
+ "unit": "mm"
+ }
+ ],
+ "features": [
+ {
+ "op": "sketch",
+ "name": "StockSketch",
+ "plane": {
+ "ref": "XY",
+ "origin": [
+ 0,
+ 0,
+ 0
+ ],
+ "x_dir": [
+ 1,
+ 0,
+ 0
+ ],
+ "y_dir": [
+ 0,
+ 1,
+ 0
+ ],
+ "normal": [
+ 0,
+ 0,
+ 1
+ ]
+ },
+ "entities": [
+ {
+ "type": "line",
+ "start": {
+ "at": [
+ 0,
+ 0
+ ]
+ },
+ "end": {
+ "at": [
+ 100,
+ 0
+ ]
+ },
+ "id": "l1"
+ },
+ {
+ "type": "line",
+ "start": {
+ "ref": "l1.end",
+ "at": [
+ 100,
+ 0
+ ]
+ },
+ "end": {
+ "at": [
+ 100,
+ 100
+ ]
+ },
+ "id": "l2"
+ },
+ {
+ "type": "line",
+ "start": {
+ "ref": "l2.end",
+ "at": [
+ 100,
+ 100
+ ]
+ },
+ "end": {
+ "at": [
+ 0,
+ 100
+ ]
+ },
+ "id": "l3"
+ },
+ {
+ "type": "line",
+ "start": {
+ "ref": "l3.end",
+ "at": [
+ 0,
+ 100
+ ]
+ },
+ "end": {
+ "ref": "l1.start",
+ "at": [
+ 0,
+ 0
+ ]
+ },
+ "id": "l4"
+ },
+ {
+ "type": "circle",
+ "id": "bore_circle_1",
+ "center": {
+ "at": [
+ 20,
+ 20
+ ]
+ },
+ "radius": 5,
+ "construction": true
+ },
+ {
+ "type": "circle",
+ "id": "bore_circle_2",
+ "center": {
+ "at": [
+ 60,
+ 50
+ ]
+ },
+ "radius": 5,
+ "construction": true
+ }
+ ],
+ "constraints": [
+ {
+ "type": "coincident",
+ "refs": [
+ "l1.start",
+ "origin"
+ ]
+ },
+ {
+ "type": "horizontal",
+ "refs": [
+ "l1"
+ ]
+ },
+ {
+ "type": "vertical",
+ "refs": [
+ "l2"
+ ]
+ },
+ {
+ "type": "horizontal",
+ "refs": [
+ "l3"
+ ]
+ },
+ {
+ "type": "vertical",
+ "refs": [
+ "l4"
+ ]
+ }
+ ],
+ "dimensions": [
+ {
+ "type": "distance",
+ "refs": [
+ "l1.start",
+ "l1.end"
+ ],
+ "value": "length",
+ "unit": "mm",
+ "orientation": "horizontal"
+ },
+ {
+ "type": "distance",
+ "refs": [
+ "l2.start",
+ "l2.end"
+ ],
+ "value": "width",
+ "unit": "mm",
+ "orientation": "vertical"
+ },
+ {
+ "type": "diameter",
+ "refs": [
+ "bore_circle_1"
+ ],
+ "value": "bore1_d",
+ "unit": "mm"
+ },
+ {
+ "type": "diameter",
+ "refs": [
+ "bore_circle_2"
+ ],
+ "value": "bore2_d",
+ "unit": "mm"
+ }
+ ]
+ },
+ {
+ "op": "extrude",
+ "name": "Stock",
+ "operation": "new",
+ "profiles": [
+ {
+ "sketch": "StockSketch",
+ "loops": [
+ {
+ "outer": true,
+ "curves": [
+ "l1",
+ "l2",
+ "l3",
+ "l4"
+ ]
+ }
+ ]
+ }
+ ],
+ "extent": {
+ "type": "distance",
+ "distance": "thickness",
+ "direction": "positive"
+ },
+ "result_bodies": [
+ "Plate"
+ ]
+ },
+ {
+ "op": "hole",
+ "name": "Bore1",
+ "hole_type": "simple",
+ "face": {
+ "type": "plane",
+ "normal_at_point_on_face": [
+ 0,
+ 0,
+ 1
+ ],
+ "plane_normal_outward": [
+ 0,
+ 0,
+ 1
+ ],
+ "point": [
+ 50,
+ 50,
+ 20
+ ]
+ },
+ "position": [
+ 20,
+ 20,
+ 20
+ ],
+ "direction": "into the material (-Z)",
+ "diameter": "bore1_d",
+ "extent": "through_all"
+ },
+ {
+ "op": "hole",
+ "name": "Bore2",
+ "hole_type": "simple",
+ "face": {
+ "type": "plane",
+ "normal_at_point_on_face": [
+ 0,
+ 0,
+ 1
+ ],
+ "plane_normal_outward": [
+ 0,
+ 0,
+ 1
+ ],
+ "point": [
+ 50,
+ 50,
+ 20
+ ]
+ },
+ "position": [
+ 60,
+ 50,
+ 20
+ ],
+ "direction": "into the material (-Z)",
+ "diameter": "bore2_d",
+ "extent": "through_all"
+ }
+ ]
+}
diff --git a/tests/oracle/86-plate-first-bore-12/expected.json b/tests/oracle/86-plate-first-bore-12/expected.json
new file mode 100644
index 0000000000..757b85d822
--- /dev/null
+++ b/tests/oracle/86-plate-first-bore-12/expected.json
@@ -0,0 +1,25 @@
+{
+ "source": "analytic",
+ "method": "Plate L=100, W=80, T=20 mm; Bore1 at (20,20) Ø12; Bore2 at (60,50) Ø10. Box minus independently located through-cylinders: V=LWT-sum(pi*d²*T/4), area=2(LW+LT+WT)+sum(pi*d*T-pi*d²/2), mass moments from exact box minus cylinders. Shape: rectangular",
+ "body_count": 1,
+ "volume_mm3": 156167.25696262045,
+ "area_mm2": 24199.026463841554,
+ "center_of_mass": [
+ 50.333939643071744,
+ 40.189098352100864,
+ 10
+ ],
+ "bbox": {
+ "min": [
+ 0,
+ 0,
+ 0
+ ],
+ "max": [
+ 100,
+ 80,
+ 20
+ ]
+ },
+ "faces": 8
+}
diff --git a/tests/oracle/86-plate-first-bore-12/recipe.json b/tests/oracle/86-plate-first-bore-12/recipe.json
new file mode 100644
index 0000000000..94001ad6bf
--- /dev/null
+++ b/tests/oracle/86-plate-first-bore-12/recipe.json
@@ -0,0 +1,335 @@
+{
+ "id": "86-plate-first-bore-12",
+ "name": "Workshop plate after Bore1 diameter changes to Ø12",
+ "description": "Parameterized rectangular workshop plate 100 x 80 x 20 mm with 2 independent through bores. World origin at (0,0,0).",
+ "exercises": [
+ "extrude",
+ "hole_through_all",
+ "drawing_w23_acceptance"
+ ],
+ "units": {
+ "length": "mm",
+ "angle": "deg",
+ "area": "mm2",
+ "volume": "mm3"
+ },
+ "conventions": {
+ "world": "right-handed; Z up. XY/XZ/YZ are the origin planes.",
+ "sketch_frame": "sketch-local 2D coords; world = plane.origin + x*plane.x_dir + y*plane.y_dir (origin in mm). Profile 'loops' list sketch entity ids.",
+ "point_refs": "'<id>.start' / '<id>.end' / '<id>.center' reuse (share) that existing sketch point; 'at' is its position when referenced.",
+ "extrude_direction": "positive = along sketch plane normal unless stated",
+ "selections": "selected faces/edges carry 'point': a world-space point on the face / the edge's parametric midpoint; pick the nearest face/edge to it."
+ },
+ "parameters": [
+ {
+ "name": "length",
+ "expression": "100 mm",
+ "unit": "mm"
+ },
+ {
+ "name": "width",
+ "expression": "80 mm",
+ "unit": "mm"
+ },
+ {
+ "name": "thickness",
+ "expression": "20 mm",
+ "unit": "mm"
+ },
+ {
+ "name": "bore1_d",
+ "expression": "12 mm",
+ "unit": "mm"
+ },
+ {
+ "name": "bore2_d",
+ "expression": "10 mm",
+ "unit": "mm"
+ }
+ ],
+ "features": [
+ {
+ "op": "sketch",
+ "name": "StockSketch",
+ "plane": {
+ "ref": "XY",
+ "origin": [
+ 0,
+ 0,
+ 0
+ ],
+ "x_dir": [
+ 1,
+ 0,
+ 0
+ ],
+ "y_dir": [
+ 0,
+ 1,
+ 0
+ ],
+ "normal": [
+ 0,
+ 0,
+ 1
+ ]
+ },
+ "entities": [
+ {
+ "type": "line",
+ "start": {
+ "at": [
+ 0,
+ 0
+ ]
+ },
+ "end": {
+ "at": [
+ 100,
+ 0
+ ]
+ },
+ "id": "l1"
+ },
+ {
+ "type": "line",
+ "start": {
+ "ref": "l1.end",
+ "at": [
+ 100,
+ 0
+ ]
+ },
+ "end": {
+ "at": [
+ 100,
+ 80
+ ]
+ },
+ "id": "l2"
+ },
+ {
+ "type": "line",
+ "start": {
+ "ref": "l2.end",
+ "at": [
+ 100,
+ 80
+ ]
+ },
+ "end": {
+ "at": [
+ 0,
+ 80
+ ]
+ },
+ "id": "l3"
+ },
+ {
+ "type": "line",
+ "start": {
+ "ref": "l3.end",
+ "at": [
+ 0,
+ 80
+ ]
+ },
+ "end": {
+ "ref": "l1.start",
+ "at": [
+ 0,
+ 0
+ ]
+ },
+ "id": "l4"
+ },
+ {
+ "type": "circle",
+ "id": "bore_circle_1",
+ "center": {
+ "at": [
+ 20,
+ 20
+ ]
+ },
+ "radius": 6,
+ "construction": true
+ },
+ {
+ "type": "circle",
+ "id": "bore_circle_2",
+ "center": {
+ "at": [
+ 60,
+ 50
+ ]
+ },
+ "radius": 5,
+ "construction": true
+ }
+ ],
+ "constraints": [
+ {
+ "type": "coincident",
+ "refs": [
+ "l1.start",
+ "origin"
+ ]
+ },
+ {
+ "type": "horizontal",
+ "refs": [
+ "l1"
+ ]
+ },
+ {
+ "type": "vertical",
+ "refs": [
+ "l2"
+ ]
+ },
+ {
+ "type": "horizontal",
+ "refs": [
+ "l3"
+ ]
+ },
+ {
+ "type": "vertical",
+ "refs": [
+ "l4"
+ ]
+ }
+ ],
+ "dimensions": [
+ {
+ "type": "distance",
+ "refs": [
+ "l1.start",
+ "l1.end"
+ ],
+ "value": "length",
+ "unit": "mm",
+ "orientation": "horizontal"
+ },
+ {
+ "type": "distance",
+ "refs": [
+ "l2.start",
+ "l2.end"
+ ],
+ "value": "width",
+ "unit": "mm",
+ "orientation": "vertical"
+ },
+ {
+ "type": "diameter",
+ "refs": [
+ "bore_circle_1"
+ ],
+ "value": "bore1_d",
+ "unit": "mm"
+ },
+ {
+ "type": "diameter",
+ "refs": [
+ "bore_circle_2"
+ ],
+ "value": "bore2_d",
+ "unit": "mm"
+ }
+ ]
+ },
+ {
+ "op": "extrude",
+ "name": "Stock",
+ "operation": "new",
+ "profiles": [
+ {
+ "sketch": "StockSketch",
+ "loops": [
+ {
+ "outer": true,
+ "curves": [
+ "l1",
+ "l2",
+ "l3",
+ "l4"
+ ]
+ }
+ ]
+ }
+ ],
+ "extent": {
+ "type": "distance",
+ "distance": "thickness",
+ "direction": "positive"
+ },
+ "result_bodies": [
+ "Plate"
+ ]
+ },
+ {
+ "op": "hole",
+ "name": "Bore1",
+ "hole_type": "simple",
+ "face": {
+ "type": "plane",
+ "normal_at_point_on_face": [
+ 0,
+ 0,
+ 1
+ ],
+ "plane_normal_outward": [
+ 0,
+ 0,
+ 1
+ ],
+ "point": [
+ 50,
+ 40,
+ 20
+ ]
+ },
+ "position": [
+ 20,
+ 20,
+ 20
+ ],
+ "direction": "into the material (-Z)",
+ "diameter": "bore1_d",
+ "extent": "through_all"
+ },
+ {
+ "op": "hole",
+ "name": "Bore2",
+ "hole_type": "simple",
+ "face": {
+ "type": "plane",
+ "normal_at_point_on_face": [
+ 0,
+ 0,
+ 1
+ ],
+ "plane_normal_outward": [
+ 0,
+ 0,
+ 1
+ ],
+ "point": [
+ 50,
+ 40,
+ 20
+ ]
+ },
+ "position": [
+ 60,
+ 50,
+ 20
+ ],
+ "direction": "into the material (-Z)",
+ "diameter": "bore2_d",
+ "extent": "through_all"
+ }
+ ]
+}
diff --git a/tests/oracle/87-plate-bore1-deleted/expected.json b/tests/oracle/87-plate-bore1-deleted/expected.json
new file mode 100644
index 0000000000..af3dbefe01
--- /dev/null
+++ b/tests/oracle/87-plate-bore1-deleted/expected.json
@@ -0,0 +1,25 @@
+{
+ "source": "analytic",
+ "method": "Plate L=100, W=80, T=20 mm; Bore2 at (60,50) Ø10. Box minus independently located through-cylinders: V=LWT-sum(pi*d²*T/4), area=2(LW+LT+WT)+sum(pi*d*T-pi*d²/2), mass moments from exact box minus cylinders. Shape: rectangular",
+ "body_count": 1,
+ "volume_mm3": 158429.2036732051,
+ "area_mm2": 23671.238898038468,
+ "center_of_mass": [
+ 49.900851844838215,
+ 39.900851844838215,
+ 10
+ ],
+ "bbox": {
+ "min": [
+ 0,
+ 0,
+ 0
+ ],
+ "max": [
+ 100,
+ 80,
+ 20
+ ]
+ },
+ "faces": 7
+}
diff --git a/tests/oracle/87-plate-bore1-deleted/recipe.json b/tests/oracle/87-plate-bore1-deleted/recipe.json
new file mode 100644
index 0000000000..91ad0dd58d
--- /dev/null
+++ b/tests/oracle/87-plate-bore1-deleted/recipe.json
@@ -0,0 +1,284 @@
+{
+ "id": "87-plate-bore1-deleted",
+ "name": "Workshop plate retaining Bore2 after Bore1 deletion",
+ "description": "Plate 100 x 80 x 20 mm after deleting Bore1, keeping the original Bore2 identity and XY (60,50), Ø10.",
+ "exercises": [
+ "extrude",
+ "hole_through_all",
+ "drawing_w23_acceptance"
+ ],
+ "units": {
+ "length": "mm",
+ "angle": "deg",
+ "area": "mm2",
+ "volume": "mm3"
+ },
+ "conventions": {
+ "world": "right-handed; Z up. XY/XZ/YZ are the origin planes.",
+ "sketch_frame": "sketch-local 2D coords; world = plane.origin + x*plane.x_dir + y*plane.y_dir (origin in mm). Profile 'loops' list sketch entity ids.",
+ "point_refs": "'<id>.start' / '<id>.end' / '<id>.center' reuse (share) that existing sketch point; 'at' is its position when referenced.",
+ "extrude_direction": "positive = along sketch plane normal unless stated",
+ "selections": "selected faces/edges carry 'point': a world-space point on the face / the edge's parametric midpoint; pick the nearest face/edge to it."
+ },
+ "parameters": [
+ {
+ "name": "length",
+ "expression": "100 mm",
+ "unit": "mm"
+ },
+ {
+ "name": "width",
+ "expression": "80 mm",
+ "unit": "mm"
+ },
+ {
+ "name": "thickness",
+ "expression": "20 mm",
+ "unit": "mm"
+ },
+ {
+ "name": "bore1_d",
+ "expression": "10 mm",
+ "unit": "mm"
+ },
+ {
+ "name": "bore2_d",
+ "expression": "10 mm",
+ "unit": "mm"
+ }
+ ],
+ "features": [
+ {
+ "op": "sketch",
+ "name": "StockSketch",
+ "plane": {
+ "ref": "XY",
+ "origin": [
+ 0,
+ 0,
+ 0
+ ],
+ "x_dir": [
+ 1,
+ 0,
+ 0
+ ],
+ "y_dir": [
+ 0,
+ 1,
+ 0
+ ],
+ "normal": [
+ 0,
+ 0,
+ 1
+ ]
+ },
+ "entities": [
+ {
+ "type": "line",
+ "start": {
+ "at": [
+ 0,
+ 0
+ ]
+ },
+ "end": {
+ "at": [
+ 100,
+ 0
+ ]
+ },
+ "id": "l1"
+ },
+ {
+ "type": "line",
+ "start": {
+ "ref": "l1.end",
+ "at": [
+ 100,
+ 0
+ ]
+ },
+ "end": {
+ "at": [
+ 100,
+ 80
+ ]
+ },
+ "id": "l2"
+ },
+ {
+ "type": "line",
+ "start": {
+ "ref": "l2.end",
+ "at": [
+ 100,
+ 80
+ ]
+ },
+ "end": {
+ "at": [
+ 0,
+ 80
+ ]
+ },
+ "id": "l3"
+ },
+ {
+ "type": "line",
+ "start": {
+ "ref": "l3.end",
+ "at": [
+ 0,
+ 80
+ ]
+ },
+ "end": {
+ "ref": "l1.start",
+ "at": [
+ 0,
+ 0
+ ]
+ },
+ "id": "l4"
+ },
+ {
+ "type": "circle",
+ "id": "bore_circle_2",
+ "center": {
+ "at": [
+ 60,
+ 50
+ ]
+ },
+ "radius": 5,
+ "construction": true
+ }
+ ],
+ "constraints": [
+ {
+ "type": "coincident",
+ "refs": [
+ "l1.start",
+ "origin"
+ ]
+ },
+ {
+ "type": "horizontal",
+ "refs": [
+ "l1"
+ ]
+ },
+ {
+ "type": "vertical",
+ "refs": [
+ "l2"
+ ]
+ },
+ {
+ "type": "horizontal",
+ "refs": [
+ "l3"
+ ]
+ },
+ {
+ "type": "vertical",
+ "refs": [
+ "l4"
+ ]
+ }
+ ],
+ "dimensions": [
+ {
+ "type": "distance",
+ "refs": [
+ "l1.start",
+ "l1.end"
+ ],
+ "value": "length",
+ "unit": "mm",
+ "orientation": "horizontal"
+ },
+ {
+ "type": "distance",
+ "refs": [
+ "l2.start",
+ "l2.end"
+ ],
+ "value": "width",
+ "unit": "mm",
+ "orientation": "vertical"
+ },
+ {
+ "type": "diameter",
+ "refs": [
+ "bore_circle_2"
+ ],
+ "value": "bore2_d",
+ "unit": "mm"
+ }
+ ]
+ },
+ {
+ "op": "extrude",
+ "name": "Stock",
+ "operation": "new",
+ "profiles": [
+ {
+ "sketch": "StockSketch",
+ "loops": [
+ {
+ "outer": true,
+ "curves": [
+ "l1",
+ "l2",
+ "l3",
+ "l4"
+ ]
+ }
+ ]
+ }
+ ],
+ "extent": {
+ "type": "distance",
+ "distance": "thickness",
+ "direction": "positive"
+ },
+ "result_bodies": [
+ "Plate"
+ ]
+ },
+ {
+ "op": "hole",
+ "name": "Bore2",
+ "hole_type": "simple",
+ "face": {
+ "type": "plane",
+ "normal_at_point_on_face": [
+ 0,
+ 0,
+ 1
+ ],
+ "plane_normal_outward": [
+ 0,
+ 0,
+ 1
+ ],
+ "point": [
+ 50,
+ 40,
+ 20
+ ]
+ },
+ "position": [
+ 60,
+ 50,
+ 20
+ ],
+ "direction": "into the material (-Z)",
+ "diameter": "bore2_d",
+ "extent": "through_all"
+ }
+ ]
+}
diff --git a/tests/oracle/88-plate-four-bores/expected.json b/tests/oracle/88-plate-four-bores/expected.json
new file mode 100644
index 0000000000..661522d84c
--- /dev/null
+++ b/tests/oracle/88-plate-four-bores/expected.json
@@ -0,0 +1,25 @@
+{
+ "source": "analytic",
+ "method": "Plate L=150, W=80, T=10 mm; Bore1 at (15,15) Ø8; Bore2 at (135,15) Ø8; Bore3 at (15,65) Ø8; Bore4 at (135,65) Ø8. Box minus independently located through-cylinders: V=LWT-sum(pi*d²*T/4), area=2(LW+LT+WT)+sum(pi*d*T-pi*d²/2), mass moments from exact box minus cylinders. Shape: rectangular",
+ "body_count": 1,
+ "volume_mm3": 117989.38070170255,
+ "area_mm2": 29203.185789489246,
+ "center_of_mass": [
+ 74.99999999999999,
+ 40,
+ 5
+ ],
+ "bbox": {
+ "min": [
+ 0,
+ 0,
+ 0
+ ],
+ "max": [
+ 150,
+ 80,
+ 10
+ ]
+ },
+ "faces": 10
+}
diff --git a/tests/oracle/88-plate-four-bores/recipe.json b/tests/oracle/88-plate-four-bores/recipe.json
new file mode 100644
index 0000000000..3ddca81888
--- /dev/null
+++ b/tests/oracle/88-plate-four-bores/recipe.json
@@ -0,0 +1,447 @@
+{
+ "id": "88-plate-four-bores",
+ "name": "Workshop plate with four Ø8 through bores",
+ "description": "Parameterized rectangular workshop plate 150 x 80 x 10 mm with 4 independent through bores. World origin at (0,0,0).",
+ "exercises": [
+ "extrude",
+ "hole_through_all",
+ "drawing_w23_acceptance"
+ ],
+ "units": {
+ "length": "mm",
+ "angle": "deg",
+ "area": "mm2",
+ "volume": "mm3"
+ },
+ "conventions": {
+ "world": "right-handed; Z up. XY/XZ/YZ are the origin planes.",
+ "sketch_frame": "sketch-local 2D coords; world = plane.origin + x*plane.x_dir + y*plane.y_dir (origin in mm). Profile 'loops' list sketch entity ids.",
+ "point_refs": "'<id>.start' / '<id>.end' / '<id>.center' reuse (share) that existing sketch point; 'at' is its position when referenced.",
+ "extrude_direction": "positive = along sketch plane normal unless stated",
+ "selections": "selected faces/edges carry 'point': a world-space point on the face / the edge's parametric midpoint; pick the nearest face/edge to it."
+ },
+ "parameters": [
+ {
+ "name": "length",
+ "expression": "150 mm",
+ "unit": "mm"
+ },
+ {
+ "name": "width",
+ "expression": "80 mm",
+ "unit": "mm"
+ },
+ {
+ "name": "thickness",
+ "expression": "10 mm",
+ "unit": "mm"
+ },
+ {
+ "name": "bore1_d",
+ "expression": "8 mm",
+ "unit": "mm"
+ },
+ {
+ "name": "bore2_d",
+ "expression": "8 mm",
+ "unit": "mm"
+ },
+ {
+ "name": "bore3_d",
+ "expression": "8 mm",
+ "unit": "mm"
+ },
+ {
+ "name": "bore4_d",
+ "expression": "8 mm",
+ "unit": "mm"
+ }
+ ],
+ "features": [
+ {
+ "op": "sketch",
+ "name": "StockSketch",
+ "plane": {
+ "ref": "XY",
+ "origin": [
+ 0,
+ 0,
+ 0
+ ],
+ "x_dir": [
+ 1,
+ 0,
+ 0
+ ],
+ "y_dir": [
+ 0,
+ 1,
+ 0
+ ],
+ "normal": [
+ 0,
+ 0,
+ 1
+ ]
+ },
+ "entities": [
+ {
+ "type": "line",
+ "start": {
+ "at": [
+ 0,
+ 0
+ ]
+ },
+ "end": {
+ "at": [
+ 150,
+ 0
+ ]
+ },
+ "id": "l1"
+ },
+ {
+ "type": "line",
+ "start": {
+ "ref": "l1.end",
+ "at": [
+ 150,
+ 0
+ ]
+ },
+ "end": {
+ "at": [
+ 150,
+ 80
+ ]
+ },
+ "id": "l2"
+ },
+ {
+ "type": "line",
+ "start": {
+ "ref": "l2.end",
+ "at": [
+ 150,
+ 80
+ ]
+ },
+ "end": {
+ "at": [
+ 0,
+ 80
+ ]
+ },
+ "id": "l3"
+ },
+ {
+ "type": "line",
+ "start": {
+ "ref": "l3.end",
+ "at": [
+ 0,
+ 80
+ ]
+ },
+ "end": {
+ "ref": "l1.start",
+ "at": [
+ 0,
+ 0
+ ]
+ },
+ "id": "l4"
+ },
+ {
+ "type": "circle",
+ "id": "bore_circle_1",
+ "center": {
+ "at": [
+ 15,
+ 15
+ ]
+ },
+ "radius": 4,
+ "construction": true
+ },
+ {
+ "type": "circle",
+ "id": "bore_circle_2",
+ "center": {
+ "at": [
+ 135,
+ 15
+ ]
+ },
+ "radius": 4,
+ "construction": true
+ },
+ {
+ "type": "circle",
+ "id": "bore_circle_3",
+ "center": {
+ "at": [
+ 15,
+ 65
+ ]
+ },
+ "radius": 4,
+ "construction": true
+ },
+ {
+ "type": "circle",
+ "id": "bore_circle_4",
+ "center": {
+ "at": [
+ 135,
+ 65
+ ]
+ },
+ "radius": 4,
+ "construction": true
+ }
+ ],
+ "constraints": [
+ {
+ "type": "coincident",
+ "refs": [
+ "l1.start",
+ "origin"
+ ]
+ },
+ {
+ "type": "horizontal",
+ "refs": [
+ "l1"
+ ]
+ },
+ {
+ "type": "vertical",
+ "refs": [
+ "l2"
+ ]
+ },
+ {
+ "type": "horizontal",
+ "refs": [
+ "l3"
+ ]
+ },
+ {
+ "type": "vertical",
+ "refs": [
+ "l4"
+ ]
+ }
+ ],
+ "dimensions": [
+ {
+ "type": "distance",
+ "refs": [
+ "l1.start",
+ "l1.end"
+ ],
+ "value": "length",
+ "unit": "mm",
+ "orientation": "horizontal"
+ },
+ {
+ "type": "distance",
+ "refs": [
+ "l2.start",
+ "l2.end"
+ ],
+ "value": "width",
+ "unit": "mm",
+ "orientation": "vertical"
+ },
+ {
+ "type": "diameter",
+ "refs": [
+ "bore_circle_1"
+ ],
+ "value": "bore1_d",
+ "unit": "mm"
+ },
+ {
+ "type": "diameter",
+ "refs": [
+ "bore_circle_2"
+ ],
+ "value": "bore2_d",
+ "unit": "mm"
+ },
+ {
+ "type": "diameter",
+ "refs": [
+ "bore_circle_3"
+ ],
+ "value": "bore3_d",
+ "unit": "mm"
+ },
+ {
+ "type": "diameter",
+ "refs": [
+ "bore_circle_4"
+ ],
+ "value": "bore4_d",
+ "unit": "mm"
+ }
+ ]
+ },
+ {
+ "op": "extrude",
+ "name": "Stock",
+ "operation": "new",
+ "profiles": [
+ {
+ "sketch": "StockSketch",
+ "loops": [
+ {
+ "outer": true,
+ "curves": [
+ "l1",
+ "l2",
+ "l3",
+ "l4"
+ ]
+ }
+ ]
+ }
+ ],
+ "extent": {
+ "type": "distance",
+ "distance": "thickness",
+ "direction": "positive"
+ },
+ "result_bodies": [
+ "Plate"
+ ]
+ },
+ {
+ "op": "hole",
+ "name": "Bore1",
+ "hole_type": "simple",
+ "face": {
+ "type": "plane",
+ "normal_at_point_on_face": [
+ 0,
+ 0,
+ 1
+ ],
+ "plane_normal_outward": [
+ 0,
+ 0,
+ 1
+ ],
+ "point": [
+ 75,
+ 40,
+ 10
+ ]
+ },
+ "position": [
+ 15,
+ 15,
+ 10
+ ],
+ "direction": "into the material (-Z)",
+ "diameter": "bore1_d",
+ "extent": "through_all"
+ },
+ {
+ "op": "hole",
+ "name": "Bore2",
+ "hole_type": "simple",
+ "face": {
+ "type": "plane",
+ "normal_at_point_on_face": [
+ 0,
+ 0,
+ 1
+ ],
+ "plane_normal_outward": [
+ 0,
+ 0,
+ 1
+ ],
+ "point": [
+ 75,
+ 40,
+ 10
+ ]
+ },
+ "position": [
+ 135,
+ 15,
+ 10
+ ],
+ "direction": "into the material (-Z)",
+ "diameter": "bore2_d",
+ "extent": "through_all"
+ },
+ {
+ "op": "hole",
+ "name": "Bore3",
+ "hole_type": "simple",
+ "face": {
+ "type": "plane",
+ "normal_at_point_on_face": [
+ 0,
+ 0,
+ 1
+ ],
+ "plane_normal_outward": [
+ 0,
+ 0,
+ 1
+ ],
+ "point": [
+ 75,
+ 40,
+ 10
+ ]
+ },
+ "position": [
+ 15,
+ 65,
+ 10
+ ],
+ "direction": "into the material (-Z)",
+ "diameter": "bore3_d",
+ "extent": "through_all"
+ },
+ {
+ "op": "hole",
+ "name": "Bore4",
+ "hole_type": "simple",
+ "face": {
+ "type": "plane",
+ "normal_at_point_on_face": [
+ 0,
+ 0,
+ 1
+ ],
+ "plane_normal_outward": [
+ 0,
+ 0,
+ 1
+ ],
+ "point": [
+ 75,
+ 40,
+ 10
+ ]
+ },
+ "position": [
+ 135,
+ 65,
+ 10
+ ],
+ "direction": "into the material (-Z)",
+ "diameter": "bore4_d",
+ "extent": "through_all"
+ }
+ ]
+}
diff --git a/tests/oracle/94-plate-four-rounded-corners/expected.json b/tests/oracle/94-plate-four-rounded-corners/expected.json
new file mode 100644
index 0000000000..afd13d43b7
--- /dev/null
+++ b/tests/oracle/94-plate-four-rounded-corners/expected.json
@@ -0,0 +1,25 @@
+{
+ "source": "analytic",
+ "method": "Plate L=100, W=80, T=20 mm; Bore1 at (20,20) Ø10; Bore2 at (60,50) Ø10. Box minus independently located through-cylinders: V=LWT-sum(pi*d²*T/4), area=2(LW+LT+WT)+sum(pi*d*T-pi*d²/2), mass moments from exact box minus cylinders. Shape: four exterior vertical R10 corner rounds; four corner spandrels subtract volume T*(4-pi)*R² at symmetric centroid (L/2,W/2,T/2); rounded perimeter P=2(L+W)-8R+2pi*R",
+ "body_count": 1,
+ "volume_mm3": 155141.5926535898,
+ "area_mm2": 23627.433388230813,
+ "center_of_mass": [
+ 50.20249841450349,
+ 40.10124920725174,
+ 10
+ ],
+ "bbox": {
+ "min": [
+ 0,
+ 0,
+ 0
+ ],
+ "max": [
+ 100,
+ 80,
+ 20
+ ]
+ },
+ "faces": 12
+}
diff --git a/tests/oracle/94-plate-four-rounded-corners/recipe.json b/tests/oracle/94-plate-four-rounded-corners/recipe.json
new file mode 100644
index 0000000000..ea594aff35
--- /dev/null
+++ b/tests/oracle/94-plate-four-rounded-corners/recipe.json
@@ -0,0 +1,418 @@
+{
+ "id": "94-plate-four-rounded-corners",
+ "name": "Workshop plate with four R10 vertical corner rounds",
+ "description": "100 x 80 x 20 mm workshop plate, Ø10 through-bores, four R10 vertical corner rounds.",
+ "exercises": [
+ "extrude",
+ "hole_through_all",
+ "drawing_w23_acceptance",
+ "chamfer"
+ ],
+ "units": {
+ "length": "mm",
+ "angle": "deg",
+ "area": "mm2",
+ "volume": "mm3"
+ },
+ "conventions": {
+ "world": "right-handed; Z up. XY/XZ/YZ are the origin planes.",
+ "sketch_frame": "sketch-local 2D coords; world = plane.origin + x*plane.x_dir + y*plane.y_dir (origin in mm). Profile 'loops' list sketch entity ids.",
+ "point_refs": "'<id>.start' / '<id>.end' / '<id>.center' reuse (share) that existing sketch point; 'at' is its position when referenced.",
+ "extrude_direction": "positive = along sketch plane normal unless stated",
+ "selections": "selected faces/edges carry 'point': a world-space point on the face / the edge's parametric midpoint; pick the nearest face/edge to it."
+ },
+ "parameters": [
+ {
+ "name": "length",
+ "expression": "100 mm",
+ "unit": "mm"
+ },
+ {
+ "name": "width",
+ "expression": "80 mm",
+ "unit": "mm"
+ },
+ {
+ "name": "thickness",
+ "expression": "20 mm",
+ "unit": "mm"
+ },
+ {
+ "name": "bore1_d",
+ "expression": "10 mm",
+ "unit": "mm"
+ },
+ {
+ "name": "bore2_d",
+ "expression": "10 mm",
+ "unit": "mm"
+ }
+ ],
+ "features": [
+ {
+ "op": "sketch",
+ "name": "StockSketch",
+ "plane": {
+ "ref": "XY",
+ "origin": [
+ 0,
+ 0,
+ 0
+ ],
+ "x_dir": [
+ 1,
+ 0,
+ 0
+ ],
+ "y_dir": [
+ 0,
+ 1,
+ 0
+ ],
+ "normal": [
+ 0,
+ 0,
+ 1
+ ]
+ },
+ "entities": [
+ {
+ "type": "line",
+ "start": {
+ "at": [
+ 0,
+ 0
+ ]
+ },
+ "end": {
+ "at": [
+ 100,
+ 0
+ ]
+ },
+ "id": "l1"
+ },
+ {
+ "type": "line",
+ "start": {
+ "ref": "l1.end",
+ "at": [
+ 100,
+ 0
+ ]
+ },
+ "end": {
+ "at": [
+ 100,
+ 80
+ ]
+ },
+ "id": "l2"
+ },
+ {
+ "type": "line",
+ "start": {
+ "ref": "l2.end",
+ "at": [
+ 100,
+ 80
+ ]
+ },
+ "end": {
+ "at": [
+ 0,
+ 80
+ ]
+ },
+ "id": "l3"
+ },
+ {
+ "type": "line",
+ "start": {
+ "ref": "l3.end",
+ "at": [
+ 0,
+ 80
+ ]
+ },
+ "end": {
+ "ref": "l1.start",
+ "at": [
+ 0,
+ 0
+ ]
+ },
+ "id": "l4"
+ },
+ {
+ "type": "circle",
+ "id": "bore_circle_1",
+ "center": {
+ "at": [
+ 20,
+ 20
+ ]
+ },
+ "radius": 5,
+ "construction": true
+ },
+ {
+ "type": "circle",
+ "id": "bore_circle_2",
+ "center": {
+ "at": [
+ 60,
+ 50
+ ]
+ },
+ "radius": 5,
+ "construction": true
+ }
+ ],
+ "constraints": [
+ {
+ "type": "coincident",
+ "refs": [
+ "l1.start",
+ "origin"
+ ]
+ },
+ {
+ "type": "horizontal",
+ "refs": [
+ "l1"
+ ]
+ },
+ {
+ "type": "vertical",
+ "refs": [
+ "l2"
+ ]
+ },
+ {
+ "type": "horizontal",
+ "refs": [
+ "l3"
+ ]
+ },
+ {
+ "type": "vertical",
+ "refs": [
+ "l4"
+ ]
+ }
+ ],
+ "dimensions": [
+ {
+ "type": "distance",
+ "refs": [
+ "l1.start",
+ "l1.end"
+ ],
+ "value": "length",
+ "unit": "mm",
+ "orientation": "horizontal"
+ },
+ {
+ "type": "distance",
+ "refs": [
+ "l2.start",
+ "l2.end"
+ ],
+ "value": "width",
+ "unit": "mm",
+ "orientation": "vertical"
+ },
+ {
+ "type": "diameter",
+ "refs": [
+ "bore_circle_1"
+ ],
+ "value": "bore1_d",
+ "unit": "mm"
+ },
+ {
+ "type": "diameter",
+ "refs": [
+ "bore_circle_2"
+ ],
+ "value": "bore2_d",
+ "unit": "mm"
+ }
+ ]
+ },
+ {
+ "op": "extrude",
+ "name": "Stock",
+ "operation": "new",
+ "profiles": [
+ {
+ "sketch": "StockSketch",
+ "loops": [
+ {
+ "outer": true,
+ "curves": [
+ "l1",
+ "l2",
+ "l3",
+ "l4"
+ ]
+ }
+ ]
+ }
+ ],
+ "extent": {
+ "type": "distance",
+ "distance": "thickness",
+ "direction": "positive"
+ },
+ "result_bodies": [
+ "Plate"
+ ]
+ },
+ {
+ "op": "hole",
+ "name": "Bore1",
+ "hole_type": "simple",
+ "face": {
+ "type": "plane",
+ "normal_at_point_on_face": [
+ 0,
+ 0,
+ 1
+ ],
+ "plane_normal_outward": [
+ 0,
+ 0,
+ 1
+ ],
+ "point": [
+ 50,
+ 40,
+ 20
+ ]
+ },
+ "position": [
+ 20,
+ 20,
+ 20
+ ],
+ "direction": "into the material (-Z)",
+ "diameter": "bore1_d",
+ "extent": "through_all"
+ },
+ {
+ "op": "hole",
+ "name": "Bore2",
+ "hole_type": "simple",
+ "face": {
+ "type": "plane",
+ "normal_at_point_on_face": [
+ 0,
+ 0,
+ 1
+ ],
+ "plane_normal_outward": [
+ 0,
+ 0,
+ 1
+ ],
+ "point": [
+ 50,
+ 40,
+ 20
+ ]
+ },
+ "position": [
+ 60,
+ 50,
+ 20
+ ],
+ "direction": "into the material (-Z)",
+ "diameter": "bore2_d",
+ "extent": "through_all"
+ },
+ {
+ "op": "fillet",
+ "name": "FourVerticalCornerRounds",
+ "type": "constant_radius",
+ "radius": 10,
+ "tangent_chain": false,
+ "edge_selection": "All four vertical exterior corner edges of the plate; far from both through bores",
+ "edges": [
+ {
+ "type": "line",
+ "start": [
+ 0,
+ 0,
+ 0
+ ],
+ "end": [
+ 0,
+ 0,
+ 20
+ ],
+ "point": [
+ 0,
+ 0,
+ 10
+ ]
+ },
+ {
+ "type": "line",
+ "start": [
+ 100,
+ 0,
+ 0
+ ],
+ "end": [
+ 100,
+ 0,
+ 20
+ ],
+ "point": [
+ 100,
+ 0,
+ 10
+ ]
+ },
+ {
+ "type": "line",
+ "start": [
+ 100,
+ 80,
+ 0
+ ],
+ "end": [
+ 100,
+ 80,
+ 20
+ ],
+ "point": [
+ 100,
+ 80,
+ 10
+ ]
+ },
+ {
+ "type": "line",
+ "start": [
+ 0,
+ 80,
+ 0
+ ],
+ "end": [
+ 0,
+ 80,
+ 20
+ ],
+ "point": [
+ 0,
+ 80,
+ 10
+ ]
+ }
+ ]
+ }
+ ]
+}
diff --git a/tests/oracle/95-plate-rounded-top-chamfer/expected.json b/tests/oracle/95-plate-rounded-top-chamfer/expected.json
new file mode 100644
index 0000000000..0395c14650
--- /dev/null
+++ b/tests/oracle/95-plate-rounded-top-chamfer/expected.json
@@ -0,0 +1,25 @@
+{
+ "source": "analytic",
+ "method": "Plate L=100, W=80, T=20 mm; Bore1 at (20,20) Ø10; Bore2 at (60,50) Ø10. Box minus independently located through-cylinders: V=LWT-sum(pi*d²*T/4), area=2(LW+LT+WT)+sum(pi*d*T-pi*d²/2), mass moments from exact box minus cylinders. Shape: four exterior vertical R10 corner rounds; full upper tangent loop 2 mm chamfer; four corner spandrels subtract volume T*(4-pi)*R² at symmetric centroid (L/2,W/2,T/2); rounded perimeter P=2(L+W)-8R+2pi*R; upper tangent chamfer subtracts volume Vc=P*c²/2-pi*c³/3 at (L/2,W/2,T-(P*c³/6-pi*c⁴/12)/Vc); area from upper inset face, side strips and sqrt(2)*c*(P-pi*c) bevel surface",
+ "body_count": 1,
+ "volume_mm3": 154464.30652785578,
+ "area_mm2": 23220.575727260624,
+ "center_of_mass": [
+ 50.20338631779784,
+ 40.10169315889891,
+ 9.959084781124005
+ ],
+ "bbox": {
+ "min": [
+ 0,
+ 0,
+ 0
+ ],
+ "max": [
+ 100,
+ 80,
+ 20
+ ]
+ },
+ "faces": 20
+}
diff --git a/tests/oracle/95-plate-rounded-top-chamfer/recipe.json b/tests/oracle/95-plate-rounded-top-chamfer/recipe.json
new file mode 100644
index 0000000000..af91ea9804
--- /dev/null
+++ b/tests/oracle/95-plate-rounded-top-chamfer/recipe.json
@@ -0,0 +1,447 @@
+{
+ "id": "95-plate-rounded-top-chamfer",
+ "name": "Workshop plate with four R10 corner rounds and full upper 2 mm chamfer",
+ "description": "100 x 80 x 20 mm workshop plate, Ø10 through-bores, four R10 vertical corner rounds and full upper perimeter 2 mm chamfer.",
+ "exercises": [
+ "extrude",
+ "hole_through_all",
+ "drawing_w23_acceptance",
+ "chamfer",
+ "fillet"
+ ],
+ "units": {
+ "length": "mm",
+ "angle": "deg",
+ "area": "mm2",
+ "volume": "mm3"
+ },
+ "conventions": {
+ "world": "right-handed; Z up. XY/XZ/YZ are the origin planes.",
+ "sketch_frame": "sketch-local 2D coords; world = plane.origin + x*plane.x_dir + y*plane.y_dir (origin in mm). Profile 'loops' list sketch entity ids.",
+ "point_refs": "'<id>.start' / '<id>.end' / '<id>.center' reuse (share) that existing sketch point; 'at' is its position when referenced.",
+ "extrude_direction": "positive = along sketch plane normal unless stated",
+ "selections": "selected faces/edges carry 'point': a world-space point on the face / the edge's parametric midpoint; pick the nearest face/edge to it."
+ },
+ "parameters": [
+ {
+ "name": "length",
+ "expression": "100 mm",
+ "unit": "mm"
+ },
+ {
+ "name": "width",
+ "expression": "80 mm",
+ "unit": "mm"
+ },
+ {
+ "name": "thickness",
+ "expression": "20 mm",
+ "unit": "mm"
+ },
+ {
+ "name": "bore1_d",
+ "expression": "10 mm",
+ "unit": "mm"
+ },
+ {
+ "name": "bore2_d",
+ "expression": "10 mm",
+ "unit": "mm"
+ }
+ ],
+ "features": [
+ {
+ "op": "sketch",
+ "name": "StockSketch",
+ "plane": {
+ "ref": "XY",
+ "origin": [
+ 0,
+ 0,
+ 0
+ ],
+ "x_dir": [
+ 1,
+ 0,
+ 0
+ ],
+ "y_dir": [
+ 0,
+ 1,
+ 0
+ ],
+ "normal": [
+ 0,
+ 0,
+ 1
+ ]
+ },
+ "entities": [
+ {
+ "type": "line",
+ "start": {
+ "at": [
+ 0,
+ 0
+ ]
+ },
+ "end": {
+ "at": [
+ 100,
+ 0
+ ]
+ },
+ "id": "l1"
+ },
+ {
+ "type": "line",
+ "start": {
+ "ref": "l1.end",
+ "at": [
+ 100,
+ 0
+ ]
+ },
+ "end": {
+ "at": [
+ 100,
+ 80
+ ]
+ },
+ "id": "l2"
+ },
+ {
+ "type": "line",
+ "start": {
+ "ref": "l2.end",
+ "at": [
+ 100,
+ 80
+ ]
+ },
+ "end": {
+ "at": [
+ 0,
+ 80
+ ]
+ },
+ "id": "l3"
+ },
+ {
+ "type": "line",
+ "start": {
+ "ref": "l3.end",
+ "at": [
+ 0,
+ 80
+ ]
+ },
+ "end": {
+ "ref": "l1.start",
+ "at": [
+ 0,
+ 0
+ ]
+ },
+ "id": "l4"
+ },
+ {
+ "type": "circle",
+ "id": "bore_circle_1",
+ "center": {
+ "at": [
+ 20,
+ 20
+ ]
+ },
+ "radius": 5,
+ "construction": true
+ },
+ {
+ "type": "circle",
+ "id": "bore_circle_2",
+ "center": {
+ "at": [
+ 60,
+ 50
+ ]
+ },
+ "radius": 5,
+ "construction": true
+ }
+ ],
+ "constraints": [
+ {
+ "type": "coincident",
+ "refs": [
+ "l1.start",
+ "origin"
+ ]
+ },
+ {
+ "type": "horizontal",
+ "refs": [
+ "l1"
+ ]
+ },
+ {
+ "type": "vertical",
+ "refs": [
+ "l2"
+ ]
+ },
+ {
+ "type": "horizontal",
+ "refs": [
+ "l3"
+ ]
+ },
+ {
+ "type": "vertical",
+ "refs": [
+ "l4"
+ ]
+ }
+ ],
+ "dimensions": [
+ {
+ "type": "distance",
+ "refs": [
+ "l1.start",
+ "l1.end"
+ ],
+ "value": "length",
+ "unit": "mm",
+ "orientation": "horizontal"
+ },
+ {
+ "type": "distance",
+ "refs": [
+ "l2.start",
+ "l2.end"
+ ],
+ "value": "width",
+ "unit": "mm",
+ "orientation": "vertical"
+ },
+ {
+ "type": "diameter",
+ "refs": [
+ "bore_circle_1"
+ ],
+ "value": "bore1_d",
+ "unit": "mm"
+ },
+ {
+ "type": "diameter",
+ "refs": [
+ "bore_circle_2"
+ ],
+ "value": "bore2_d",
+ "unit": "mm"
+ }
+ ]
+ },
+ {
+ "op": "extrude",
+ "name": "Stock",
+ "operation": "new",
+ "profiles": [
+ {
+ "sketch": "StockSketch",
+ "loops": [
+ {
+ "outer": true,
+ "curves": [
+ "l1",
+ "l2",
+ "l3",
+ "l4"
+ ]
+ }
+ ]
+ }
+ ],
+ "extent": {
+ "type": "distance",
+ "distance": "thickness",
+ "direction": "positive"
+ },
+ "result_bodies": [
+ "Plate"
+ ]
+ },
+ {
+ "op": "hole",
+ "name": "Bore1",
+ "hole_type": "simple",
+ "face": {
+ "type": "plane",
+ "normal_at_point_on_face": [
+ 0,
+ 0,
+ 1
+ ],
+ "plane_normal_outward": [
+ 0,
+ 0,
+ 1
+ ],
+ "point": [
+ 50,
+ 40,
+ 20
+ ]
+ },
+ "position": [
+ 20,
+ 20,
+ 20
+ ],
+ "direction": "into the material (-Z)",
+ "diameter": "bore1_d",
+ "extent": "through_all"
+ },
+ {
+ "op": "hole",
+ "name": "Bore2",
+ "hole_type": "simple",
+ "face": {
+ "type": "plane",
+ "normal_at_point_on_face": [
+ 0,
+ 0,
+ 1
+ ],
+ "plane_normal_outward": [
+ 0,
+ 0,
+ 1
+ ],
+ "point": [
+ 50,
+ 40,
+ 20
+ ]
+ },
+ "position": [
+ 60,
+ 50,
+ 20
+ ],
+ "direction": "into the material (-Z)",
+ "diameter": "bore2_d",
+ "extent": "through_all"
+ },
+ {
+ "op": "fillet",
+ "name": "FourVerticalCornerRounds",
+ "type": "constant_radius",
+ "radius": 10,
+ "tangent_chain": false,
+ "edge_selection": "All four vertical exterior corner edges of the plate; far from both through bores",
+ "edges": [
+ {
+ "type": "line",
+ "start": [
+ 0,
+ 0,
+ 0
+ ],
+ "end": [
+ 0,
+ 0,
+ 20
+ ],
+ "point": [
+ 0,
+ 0,
+ 10
+ ]
+ },
+ {
+ "type": "line",
+ "start": [
+ 100,
+ 0,
+ 0
+ ],
+ "end": [
+ 100,
+ 0,
+ 20
+ ],
+ "point": [
+ 100,
+ 0,
+ 10
+ ]
+ },
+ {
+ "type": "line",
+ "start": [
+ 100,
+ 80,
+ 0
+ ],
+ "end": [
+ 100,
+ 80,
+ 20
+ ],
+ "point": [
+ 100,
+ 80,
+ 10
+ ]
+ },
+ {
+ "type": "line",
+ "start": [
+ 0,
+ 80,
+ 0
+ ],
+ "end": [
+ 0,
+ 80,
+ 20
+ ],
+ "point": [
+ 0,
+ 80,
+ 10
+ ]
+ }
+ ]
+ },
+ {
+ "op": "chamfer",
+ "name": "FullTopPerimeterChamfer",
+ "type": "equal_distance",
+ "distance": 2,
+ "tangent_chain": true,
+ "edge_selection": "Front top straight edge after all vertical corners are rounded; tangent follow the complete top loop",
+ "edges": [
+ {
+ "type": "line",
+ "start": [
+ 10,
+ 0,
+ 20
+ ],
+ "end": [
+ 90,
+ 0,
+ 20
+ ],
+ "point": [
+ 50,
+ 0,
+ 20
+ ]
+ }
+ ]
+ }
+ ]
+}
diff --git a/tests/oracle/W23a-workshop-acceptance.md b/tests/oracle/W23a-workshop-acceptance.md
new file mode 100644
index 0000000000..1d56410977
--- /dev/null
+++ b/tests/oracle/W23a-workshop-acceptance.md
@@ -0,0 +1,115 @@
+# W23a — workshop plate fixtures and future Drawing acceptance (#4950)
+
+This contribution contains **geometry oracle recipes only**. Each is a reproducible
+SolidCraft 3D model with independently calculated body count, volume, surface
+area, centre of mass and bounds. Drawing records, persistent references, UI
+commands, drawing fonts, HLR and file exporters are **not** implemented here.
+
+Run `python3 tools/oracle-analytic/cases_workshop.py` to regenerate the
+analytic `expected.json` values; run `cargo xtask oracle` to replay every
+reference case through SolidCraft's CLI. Formula sources and method strings are
+in the script and the corresponding expected-value files.
+
+## Exact geometry and states
+
+The W23/M2 checkpoint baseline is a **100 × 80 × 20 mm** plate whose lower-left
+model corner is at XY (0, 0). Two independent through-hole features have
+identical Ø10 diameters and are 50 mm apart:
+
+| Persistent feature | Model XY centre (mm) | Model diameter (mm) |
+| --- | --- | --- |
+| `Bore1` (A) | (20, 20) | 10 |
+| `Bore2` (B) | (60, 50) | 10 |
+
+The model parameters are `length`, `width`, `thickness`, `bore1_d` and
+`bore2_d`; each hole is a separately created feature. The stock's sketch
+dimensions drive its length and width, and its extrusion depth is `thickness`.
+Each bore also has a construction-circle guide in the stock sketch with a
+diameter dimension driven by its corresponding `boreN_d` parameter. The
+individual `solid.hole` features use the same parameters and remain separate
+CAD operations; construction guides do not cut the stock.
+In an actual interactive workflow, the parameter edit is one command, not a
+rebuild from an unrelated set of fixed numbers.
+
+| Oracle case | Model state (mm) | What this verifies |
+| --- | --- | --- |
+| `84-plate-two-bores` | 100 × 80 × 20; `Bore1` Ø10 at (20,20); `Bore2` Ø10 at (60,50) | Baseline; separate references |
+| `85-plate-width-100` | 100 × 100 × 20; both bores as in 84 | Only driving `width` 80 → 100 |
+| `86-plate-first-bore-12` | 100 × 80 × 20; `Bore1` Ø12; `Bore2` Ø10 | Only `bore1_d` 10 → 12 |
+| `87-plate-bore1-deleted` | 100 × 80 × 20; only original `Bore2` Ø10 at (60,50) | Delete `Bore1`, retain `Bore2` identity |
+| `88-plate-four-bores` | 150 × 80 × 10; four Ø8 bores at (15,15), (135,15), (15,65), (135,65) | Independent four-hole workshop plate |
+| `94-plate-four-rounded-corners` | 100 × 80 × 20; both Ø10 bores; **four vertical R10 exterior corner rounds** | Rounded exterior profile |
+| `95-plate-rounded-top-chamfer` | As 94, **plus a 2 mm equal-distance chamfer along the entire tangent-connected upper perimeter** | Rounded corners and chamfered upper edges |
+
+The R10 corner cuts and full upper-perimeter 2 mm chamfer are analytic using
+the same quarter-spandrel and tangent-loop perimeter mathematics as oracle
+case 33. These revised blends require a fresh full oracle replay before they
+can be called verified.
+
+## A3 at 1:2 — geometry versus measured dimension values
+
+For the model in case 84, an A3 landscape drawing is **420 × 297 mm**,
+scale **1:2**. Its projected plate envelope on the sheet is **50 × 40 mm**;
+each Ø10 hole appears as a Ø5 circle and the 50 mm centre separation projects
+to 25 mm. **Annotation values remain in model units**: plate length 100 mm,
+plate width 80 mm, `Bore1` Ø10 mm, centre-to-centre 50 mm. Their written
+values are not halved by the view scale. Actual text metrics and display
+precision follow their eventual upstream owners (#4813 and #4896).
+
+## Acceptance sequence once drawing APIs are available
+
+Every independent edit starts from case 84; the cases in this table are
+**reference states**, not a claim that these drawing commands exist today.
+
+| Step / intended command | Owning session | Resulting source oracle state | Expected drawing measurements and labels (after Update if deferred) |
+| --- | --- | --- | --- |
+| Create baseline geometry from the case 84 recipe | **Source design** | 84 | Two independent bores and the original width 80 geometry |
+| Add a `Bore1` diameter, centre-distance and plate-width dimension | **Drawing** | 84 (unchanged) | Ø10, 50, width 80 |
+| Move the dimension labels to chosen paper-mm coordinates; save and reopen the drawing | **Drawing** | 84 (unchanged) | Every label remains at its user-chosen paper coordinate |
+| `parameters.change` `width` 80 → 100 | **Source design** | 85 | Width becomes 100; Ø10 and centre distance 50 remain; all label positions unchanged |
+| `parameters.change` `bore1_d` 10 → 12 | **Source design** | 86 | `Bore1` becomes Ø12; centre distance 50 and width 80 remain; labels unchanged |
+| `timeline.delete Bore1` | **Source design** | 87 | `Bore2` remains Ø10 with its original identity. `Bore1` diameter and linked centre-distance dimensions become **lost, kept with their last values**; no silent transfer to `Bore2` |
+| `edit.undo` immediately after any individual source edit | **Source design** | 84 | Baseline measurements Ø10 / 50 / width 80 and original reference state, after drawing Update |
+| `edit.redo` following that source undo | **Source design** | 85, 86 or 87, matching the undone edit | Edited measurements and corresponding lost/valid reference state, after drawing Update; manually placed labels retain their paper positions |
+| Update an out-of-date view in deferred mode | **Drawing** (cache update; **no new undo step**) | No source change | Drawing displays the current source state; label positions remain unchanged |
+| Undo/redo a label move or an explicit reference repair | **Drawing** | No source change | Reverts/reapplies only the drawing edit; must never undo a source model change |
+
+Both **open-drawing** and **closed-drawing** deferred-update sequences must
+be tested when the shared drawing commands land:
+
+1. **Drawing open:** Change a driving parameter. The existing drawing and
+ labels stay visibly **out of date until Update**; executing Update obtains
+ the new values and retains manual label positions.
+2. **Drawing closed:** Save and close the drawing, change the 3D model, then
+ reopen it. The saved drawing still appears out of date until Update;
+ updating does not reset manual label positions.
+3. Repeat both sequences for bore changes, deletion and **source-design**
+ undo/redo. Each source change, including its undo/redo, leaves a deferred
+ drawing **out of date until Update**; Update refreshes the view cache
+ without creating an undo step in either session. With a lost reference,
+ retain the last measured value explicitly as historical instead of
+ reporting it as a current measurement. A replacement bore at the same XY
+ and diameter must not silently restore old source identity; reference
+ repair is an explicit **drawing-session** operation.
+4. Undo/redo drawing-session label moves and reference repairs separately;
+ neither action may undo a source design's parameter edit or deletion.
+
+The coordinated drawing design allows **automatic and deferred** update
+modes (#4892). Do not introduce a separate rejected-update contract here.
+Native storage, update commands and undo ownership belong to #3890 and
+#4892; annotations and numeric formats to #4896; Drawing UI to #4894;
+sheet geometry/export to #4890. Add executable engine, desktop UI, browser
+and SVG/DXF/PDF/PNG comparisons only after those APIs are implemented.
+
+## Analytic provenance
+
+All source values use independent closed-form mathematics. For rectangular
+plates, volume is `LWT − Σπ(d/2)²T`, and surface area includes exposed
+hole walls minus circles on both stock faces. For the four vertical R10
+rounds, the section loses `(4−π)R²`; the boundary becomes
+`P = 2(L+W)−8R+2πR`. A 2 mm upper tangent-loop chamfer removes
+`V_c=Pc²/2−πc³/3` of material. The depth first moment is
+`Pc³/6−πc⁴/12`, so its removed-volume centroid is
+`z=T−(Pc³/6−πc⁴/12)/V_c`; the inward-offset perimeter shrinks with depth.
+Surface and first moments follow this exact construction.
+Calculations are regenerated by `tools/oracle-analytic/cases_workshop.py`.
diff --git a/tools/oracle-analytic/README.md b/tools/oracle-analytic/README.md
index 4a6789a2ff..19a7410e6b 100644
--- a/tools/oracle-analytic/README.md
+++ b/tools/oracle-analytic/README.md
@@ -13,6 +13,7 @@ python3 tools/oracle-analytic/cases_features.py # 32-66: fillets, shells, sw
python3 tools/oracle-analytic/cases_sheet_metal.py # 67-76: sheet metal
python3 tools/oracle-analytic/cases_fillets.py # 77-81: variable, chord-length, tapered and spline fillets
python3 tools/oracle-analytic/cases_surfaces.py # 83: boundary surfaces
+python3 tools/oracle-analytic/cases_workshop.py # W23 (#4950): parameterized plates, round corners and top chamfer
```
Where a value depends on a SolidCraft convention rather than on geometry alone (a shell's sharp
diff --git a/tools/oracle-analytic/cases_workshop.py b/tools/oracle-analytic/cases_workshop.py
new file mode 100644
index 0000000000..7dfb138345
--- /dev/null
+++ b/tools/oracle-analytic/cases_workshop.py
@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+"""Analytic expected-value writer for the W23 workshop reference plates.
+
+Run from the repository root:
+ python3 tools/oracle-analytic/cases_workshop.py
+
+All dimensions are taken from the actual parameterized oracle recipes. The
+mass properties come from exact box/cylinder subtraction, rounded rectangle
+quarter-spandrels and the same tangent-loop chamfer integration as case 33.
+No SolidCraft result is used to create any expected geometry value.
+"""
+
+import json
+import math
+from pathlib import Path
+
+from cases_features import MP, PI, box, cyl, spandrel_area, write
+
+
+ROOT = Path(__file__).resolve().parents[2] / "tests" / "oracle"
+CASES = (
+ "84-plate-two-bores",
+ "85-plate-width-100",
+ "86-plate-first-bore-12",
+ "87-plate-bore1-deleted",
+ "88-plate-four-bores",
+ "94-plate-four-rounded-corners",
+ "95-plate-rounded-top-chamfer",
+)
+
+
+def one(case):
+ recipe = json.loads((ROOT / case / "recipe.json").read_text())
+ params = {
+ p["name"]: float(p["expression"].removesuffix(" mm"))
+ for p in recipe["parameters"]
+ }
+ length, width, thickness = (params[n] for n in ("length", "width", "thickness"))
+ bores = [
+ (f["name"], float(f["position"][0]), float(f["position"][1]),
+ params[f["diameter"]])
+ for f in recipe["features"] if f["op"] == "hole"
+ ]
+ rounded = next((f for f in recipe["features"] if f["op"] == "fillet"), None)
+ chamfer = next((f for f in recipe["features"] if f["op"] == "chamfer"), None)
+ perimeter = 2 * (length + width)
+ top_area = length * width
+ solid = box(0, 0, 0, length, width, thickness)
+
+ if rounded is not None:
+ # Four R10 vertical edges remove the same quarter-square-minus-circle
+ # cross-section from each corner. Symmetry locates their combined COM.
+ r = float(rounded["radius"])
+ assert 0 < r < min(length, width) / 2
+ removed_xy = 4 * spandrel_area(r)
+ solid -= MP.at(removed_xy * thickness,
+ [length / 2, width / 2, thickness / 2])
+ top_area -= removed_xy
+ perimeter -= 8 * r - 2 * PI * r
+
+ if chamfer is not None:
+ # Constant-distance top chamfer around the entire rounded perimeter.
+ # At depth y below the top, the removed band has area
+ # P*(c-y) - pi*(c-y)^2: the inset perimeter shortens with depth.
+ # Integrate this band for exact removed volume and Z first moment.
+ c = float(chamfer["distance"])
+ assert rounded is not None and 0 < c < rounded["radius"]
+ removed = perimeter * c ** 2 / 2 - PI * c ** 3 / 3
+ mean_depth = (perimeter * c ** 3 / 6 - PI * c ** 4 / 12) / removed
+ solid -= MP.at(removed, [length / 2, width / 2,
+ thickness - mean_depth])
+ area = (2 * top_area + perimeter * thickness
+ - c * perimeter + PI * c * c
+ - c * perimeter + math.sqrt(2) * c * (perimeter - PI * c))
+ else:
+ area = 2 * top_area + perimeter * thickness
+
+ holes_desc = []
+ for name, x, y, diameter in bores:
+ radius = diameter / 2
+ solid -= cyl(x, y, radius, 0, thickness)
+ area += PI * diameter * thickness - 2 * PI * radius * radius
+ holes_desc.append(f"{name} at ({x:g},{y:g}) Ø{diameter:g}")
+
+ detail = ("rectangular" if rounded is None else
+ f"four exterior vertical R{rounded['radius']:g} corner rounds")
+ if chamfer:
+ detail += f"; full upper tangent loop {chamfer['distance']:g} mm chamfer"
+ method = (f"Plate L={length:g}, W={width:g}, T={thickness:g} mm; "
+ f"{'; '.join(holes_desc)}. Box minus independently located "
+ "through-cylinders: V=LWT-sum(pi*d²*T/4), "
+ "area=2(LW+LT+WT)+sum(pi*d*T-pi*d²/2), "
+ "mass moments from exact box minus cylinders. Shape: " + detail)
+ if rounded:
+ method += ("; four corner spandrels subtract volume "
+ "T*(4-pi)*R² at symmetric centroid (L/2,W/2,T/2); "
+ "rounded perimeter P=2(L+W)-8R+2pi*R")
+ if chamfer:
+ method += ("; upper tangent chamfer subtracts volume "
+ "Vc=P*c²/2-pi*c³/3 at "
+ "(L/2,W/2,T-(P*c³/6-pi*c⁴/12)/Vc); "
+ "area from upper inset face, side strips and "
+ "sqrt(2)*c*(P-pi*c) bevel surface")
+ # Every curved corner is one new vertical side face, in addition to
+ # four remaining straight sides, two planar caps and independent bores.
+ # A complete tangent-chain top chamfer contributes eight more faces:
+ # one over each of the four straight runs and four R10 corner arcs.
+ faces = 6 + len(bores) + (4 if rounded else 0) + (8 if chamfer else 0)
+ write(case, method, 1, solid, area,
+ [(0, 0, 0), (length, width, thickness)], faces=faces)
+
+
+if __name__ == "__main__":
+ for fixture in CASES:
+ one(fixture)