mirror of
https://github.com/storytold/cadcraft.git
synced 2026-11-15 18:31:02 -06:00
Compare commits
16
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
0e3f62f50d | ||
|
|
f9c0c96e63 | ||
|
|
1069c8217a | ||
|
|
6dfc0ef6a2 | ||
|
|
e7a51dcc3d | ||
|
|
a20a46f7c3 | ||
|
|
8a4e275466 | ||
|
|
6749299b95 | ||
|
|
4072f84290 | ||
|
|
f877213876 | ||
|
|
06203e4958 | ||
|
|
fefb973754 | ||
|
|
ff2163ddfe | ||
|
|
64f707968f | ||
|
|
2ac6d98dac | ||
|
|
a84de56183 |
Generated
+19
@@ -759,6 +759,8 @@ dependencies = [
|
||||
"cadcraft-io",
|
||||
"cadcraft-render",
|
||||
"clap",
|
||||
"craft-jsonrpc",
|
||||
"craft-mcp",
|
||||
"getrandom 0.4.3",
|
||||
"libc",
|
||||
"log",
|
||||
@@ -1189,6 +1191,23 @@ dependencies = [
|
||||
"writeable",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-jsonrpc"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=b6222158fbc2a628f27d2c1fff9f648cd194404c#b6222158fbc2a628f27d2c1fff9f648cd194404c"
|
||||
dependencies = [
|
||||
"serde_json",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-mcp"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=b6222158fbc2a628f27d2c1fff9f648cd194404c#b6222158fbc2a628f27d2c1fff9f648cd194404c"
|
||||
dependencies = [
|
||||
"craft-jsonrpc",
|
||||
"serde_json",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-mime"
|
||||
version = "0.1.0"
|
||||
|
||||
@@ -26,6 +26,8 @@ cadcraft-io = { path = "crates/io" }
|
||||
cadcraft-engine = { path = "crates/engine" }
|
||||
cadcraft-ui-egui = { path = "crates/ui-egui" }
|
||||
cadcraft-mcp = { path = "crates/mcp" }
|
||||
craft-mcp = { git = "https://github.com/storytold/craft-libs", rev = "b6222158fbc2a628f27d2c1fff9f648cd194404c" }
|
||||
craft-jsonrpc = { git = "https://github.com/storytold/craft-libs", rev = "b6222158fbc2a628f27d2c1fff9f648cd194404c" }
|
||||
# Which paths stored in a drawing (xrefs, data links) may be opened.
|
||||
craft-docpath = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "92d392cff132eaf53e13afff77f38b5c11b73aa0" }
|
||||
# PDF writing (krilla) for plots, and reading them back in tests. The root patches below pin
|
||||
|
||||
+40
-24
@@ -1,5 +1,5 @@
|
||||
//! CAD colours: the 256-entry colour index (ACI), 24-bit true colour, and the logical
|
||||
//! ByLayer / ByBlock values. The index palette is generated from its well-known structure
|
||||
//! `ByLayer` / `ByBlock` values. The index palette is generated from its well-known structure
|
||||
//! (24 hues × 5 values × 2 saturations, plus primaries and greys), not copied from any file.
|
||||
#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
|
||||
#![forbid(unsafe_code)]
|
||||
@@ -11,12 +11,15 @@ use serde::{Deserialize, Serialize};
|
||||
pub struct Rgb(pub u8, pub u8, pub u8);
|
||||
|
||||
impl Rgb {
|
||||
#[must_use]
|
||||
pub fn to_u32(self) -> u32 {
|
||||
(u32::from(self.0) << 16) | (u32::from(self.1) << 8) | u32::from(self.2)
|
||||
}
|
||||
#[must_use]
|
||||
pub fn from_u32(v: u32) -> Rgb {
|
||||
Rgb(((v >> 16) & 0xff) as u8, ((v >> 8) & 0xff) as u8, (v & 0xff) as u8)
|
||||
}
|
||||
#[must_use]
|
||||
pub fn hex(self) -> String {
|
||||
format!("#{:02x}{:02x}{:02x}", self.0, self.1, self.2)
|
||||
}
|
||||
@@ -29,6 +32,7 @@ impl Rgb {
|
||||
u32::from_str_radix(s, 16).ok().map(Rgb::from_u32)
|
||||
}
|
||||
/// Relative luminance (0..1) for contrast decisions.
|
||||
#[must_use]
|
||||
pub fn luma(self) -> f64 {
|
||||
(0.2126 * f64::from(self.0) + 0.7152 * f64::from(self.1) + 0.0722 * f64::from(self.2)) / 255.0
|
||||
}
|
||||
@@ -48,7 +52,8 @@ pub enum Color {
|
||||
|
||||
impl Color {
|
||||
pub const WHITE: Color = Color::Index(7);
|
||||
/// DXF group 62 value: 0 = ByBlock, 256 = ByLayer.
|
||||
/// DXF group 62 value: 0 = `ByBlock`, 256 = `ByLayer`.
|
||||
#[must_use]
|
||||
pub fn to_aci(self) -> i16 {
|
||||
match self {
|
||||
Color::ByLayer => 256,
|
||||
@@ -57,14 +62,16 @@ impl Color {
|
||||
Color::True(rgb) => i16::from(nearest_aci(rgb)),
|
||||
}
|
||||
}
|
||||
#[must_use]
|
||||
pub fn from_aci(v: i16) -> Color {
|
||||
match v {
|
||||
0 => Color::ByBlock,
|
||||
1..=255 => Color::Index(v as u8),
|
||||
1..=255 => u8::try_from(v).map_or(Color::ByLayer, Color::Index),
|
||||
_ => Color::ByLayer,
|
||||
}
|
||||
}
|
||||
/// Resolve to RGB given the layer and block colours.
|
||||
#[must_use]
|
||||
pub fn resolve(self, layer: Color, block: Color) -> Rgb {
|
||||
match self {
|
||||
Color::ByLayer => match layer {
|
||||
@@ -79,7 +86,8 @@ impl Color {
|
||||
Color::True(c) => c,
|
||||
}
|
||||
}
|
||||
/// Short display name like AutoCAD's Properties palette ("ByLayer", "Red", "Color 34", "255,128,0").
|
||||
/// Short display name like `AutoCAD`'s Properties palette ("`ByLayer`", "Red", "Color 34", "255,128,0").
|
||||
#[must_use]
|
||||
pub fn name(self) -> String {
|
||||
match self {
|
||||
Color::ByLayer => "ByLayer".into(),
|
||||
@@ -102,7 +110,7 @@ impl Color {
|
||||
let t = s.trim().to_ascii_lowercase();
|
||||
let named = ["", "red", "yellow", "green", "cyan", "blue", "magenta", "white"];
|
||||
if let Some(i) = named.iter().position(|n| !n.is_empty() && *n == t) {
|
||||
return Some(Color::Index(i as u8));
|
||||
return u8::try_from(i).ok().map(Color::Index);
|
||||
}
|
||||
match t.as_str() {
|
||||
"bylayer" => return Some(Color::ByLayer),
|
||||
@@ -117,7 +125,7 @@ impl Color {
|
||||
return match i {
|
||||
0 => Some(Color::ByBlock),
|
||||
256 => Some(Color::ByLayer),
|
||||
1..=255 => Some(Color::Index(i as u8)),
|
||||
1..=255 => u8::try_from(i).ok().map(Color::Index),
|
||||
_ => None,
|
||||
};
|
||||
}
|
||||
@@ -145,11 +153,16 @@ pub fn aci_rgb(i: u8) -> Rgb {
|
||||
PALETTE.get(usize::from(i)).copied().unwrap_or(Rgb(255, 255, 255))
|
||||
}
|
||||
|
||||
/// The palette as a 256-entry table (entry 0 = ByBlock placeholder = black).
|
||||
/// The palette as a 256-entry table (entry 0 = `ByBlock` placeholder = black).
|
||||
pub static PALETTE: std::sync::LazyLock<[Rgb; 256]> = std::sync::LazyLock::new(build_palette);
|
||||
|
||||
#[expect(
|
||||
clippy::cast_possible_truncation,
|
||||
clippy::cast_sign_loss,
|
||||
reason = "Palette channels are finite and clamped to the u8 range before conversion."
|
||||
)]
|
||||
fn build_palette() -> [Rgb; 256] {
|
||||
let mut p = [Rgb(0, 0, 0); 256];
|
||||
let mut palette = [Rgb(0, 0, 0); 256];
|
||||
let base = [
|
||||
Rgb(0, 0, 0),
|
||||
Rgb(255, 0, 0),
|
||||
@@ -162,34 +175,35 @@ fn build_palette() -> [Rgb; 256] {
|
||||
Rgb(128, 128, 128),
|
||||
Rgb(192, 192, 192),
|
||||
];
|
||||
for (slot, c) in p.iter_mut().zip(base) {
|
||||
*slot = c;
|
||||
for (slot, colour) in palette.iter_mut().zip(base) {
|
||||
*slot = colour;
|
||||
}
|
||||
let values = [255.0, 204.0, 153.0, 127.0, 76.0];
|
||||
for i in 10..250usize {
|
||||
let hue = (i - 10) / 10; // 0..24, 15° each
|
||||
let sub = i % 10;
|
||||
let v: f64 = values.get(sub / 2).copied().unwrap_or(255.0);
|
||||
for index in 10..250usize {
|
||||
let hue = (index - 10) / 10; // 0..24, 15° each
|
||||
let sub = index % 10;
|
||||
let value: f64 = values.get(sub / 2).copied().unwrap_or(255.0);
|
||||
let half = sub % 2 == 1;
|
||||
let (r, g, b) = hue_fractions(hue);
|
||||
let ch = |f: f64| -> u8 {
|
||||
let f = if half { 0.5 + 0.5 * f } else { f };
|
||||
(v * f).floor().clamp(0.0, 255.0) as u8
|
||||
let (red, green, blue) = hue_fractions(hue);
|
||||
let channel = |fraction: f64| -> u8 {
|
||||
let fraction = if half { 0.5 + 0.5 * fraction } else { fraction };
|
||||
(value * fraction).floor().clamp(0.0, 255.0) as u8
|
||||
};
|
||||
if let Some(slot) = p.get_mut(i) {
|
||||
*slot = Rgb(ch(r), ch(g), ch(b));
|
||||
if let Some(slot) = palette.get_mut(index) {
|
||||
*slot = Rgb(channel(red), channel(green), channel(blue));
|
||||
}
|
||||
}
|
||||
let greys = [51u8, 91, 132, 173, 214, 255];
|
||||
for (k, g) in greys.iter().enumerate() {
|
||||
if let Some(slot) = p.get_mut(250 + k) {
|
||||
*slot = Rgb(*g, *g, *g);
|
||||
for (offset, shade) in greys.iter().enumerate() {
|
||||
if let Some(slot) = palette.get_mut(250 + offset) {
|
||||
*slot = Rgb(*shade, *shade, *shade);
|
||||
}
|
||||
}
|
||||
p
|
||||
palette
|
||||
}
|
||||
|
||||
/// Channel fractions for hue step 0..24 (red → yellow → green → cyan → blue → magenta → red).
|
||||
#[expect(clippy::cast_precision_loss, reason = "Only the four hue offsets 0..=3 are converted; they are exact in f64.")]
|
||||
fn hue_fractions(h: usize) -> (f64, f64, f64) {
|
||||
let seg = h / 4;
|
||||
let t = (h % 4) as f64 / 4.0;
|
||||
@@ -204,6 +218,7 @@ fn hue_fractions(h: usize) -> (f64, f64, f64) {
|
||||
}
|
||||
|
||||
/// The closest index colour to an RGB value (1..=255).
|
||||
#[must_use]
|
||||
pub fn nearest_aci(c: Rgb) -> u8 {
|
||||
let mut best = (u32::MAX, 7u8);
|
||||
for i in 1..=255u8 {
|
||||
@@ -220,6 +235,7 @@ pub fn nearest_aci(c: Rgb) -> u8 {
|
||||
/// Display colour of `c` on `background`. Colour 7 (`aci7`) flips to contrast with the
|
||||
/// background, white on dark and black on light (paper), as CAD programs draw it; every other
|
||||
/// colour, including a true-colour or index white or black, keeps its RGB.
|
||||
#[must_use]
|
||||
pub fn display_rgb(c: Rgb, aci7: bool, background: Rgb) -> Rgb {
|
||||
if !aci7 {
|
||||
c
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
//! empty, `CRAFT_FONTS` is empty and the build is unchanged. It only reads the local checkout
|
||||
//! (no network). A bad checkout is a warning, or an error with `CRAFT_FONTS_REQUIRED=1`.
|
||||
//!
|
||||
//! On wasm32 it embeds only BIZ UDPGothic Regular, the `Arab` and `Geor` faces and the `Thai`
|
||||
//! On wasm32 it embeds only `BIZ UDPGothic` Regular, the `Arab` and `Geor` faces and the `Thai`
|
||||
//! Regular faces (about 6.1 MB), to keep the web build within hosting limits (Cloudflare Pages:
|
||||
//! 25 MiB per file). The web build has no system fonts, so these are its only fallback for
|
||||
//! Japanese, Arabic-script, Georgian and Thai text.
|
||||
@@ -22,7 +22,7 @@ fn main() {
|
||||
println!("cargo::error=CRAFT_FONTS_DIR={}: {}", one_line(&dir.display().to_string()), one_line(&e));
|
||||
}
|
||||
Err(e) => {
|
||||
println!("cargo::warning=building without craft-fonts: CRAFT_FONTS_DIR={}: {}", one_line(&dir.display().to_string()), one_line(&e))
|
||||
println!("cargo::warning=building without craft-fonts: CRAFT_FONTS_DIR={}: {}", one_line(&dir.display().to_string()), one_line(&e));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -77,7 +77,7 @@ pub fn visual_runs(chars: &[char], base: Option<bool>) -> Vec<(Range<usize>, boo
|
||||
runs.into_iter()
|
||||
.filter(|r| !r.is_empty())
|
||||
.map(|r| {
|
||||
let rtl = levels.get(r.start).is_some_and(|l| l.is_rtl());
|
||||
let rtl = levels.get(r.start).is_some_and(Level::is_rtl);
|
||||
(char_at(r.start)..char_at(r.end), rtl)
|
||||
})
|
||||
.collect()
|
||||
|
||||
+50
-49
@@ -79,80 +79,81 @@ pub(crate) fn shape(primary: Option<&Face>, s: &str, height: f64, width_factor:
|
||||
|
||||
/// Lay out decoded directional runs, keeping advances and decoration spans for empty glyphs.
|
||||
fn shape_chars(primary: Option<&Face>, chars: &[(char, bool, bool)], height: f64, width_factor: f64, oblique: f64, base_rtl: Option<bool>) -> Shaped {
|
||||
let h = if height.is_finite() && height > 0.0 { height } else { 1.0 };
|
||||
let wf = if width_factor.is_finite() && width_factor.abs() > 1e-6 { width_factor } else { 1.0 };
|
||||
let normalized_height = if height.is_finite() && height > 0.0 { height } else { 1.0 };
|
||||
let scale_x = if width_factor.is_finite() && width_factor.abs() > 1e-6 { width_factor } else { 1.0 };
|
||||
let shear = oblique.tan().clamp(-10.0, 10.0);
|
||||
let sc = h / stroke::CAP;
|
||||
let cs: Vec<char> = chars.iter().map(|c| c.0).collect();
|
||||
let flags = |i: usize| chars.get(i).map(|c| (c.1, c.2)).unwrap_or((false, false));
|
||||
let mut out = Shaped::default();
|
||||
let stroke_scale = normalized_height / stroke::CAP;
|
||||
let characters: Vec<char> = chars.iter().map(|character| character.0).collect();
|
||||
let flags = |index: usize| chars.get(index).map_or((false, false), |character| (character.1, character.2));
|
||||
let mut shaped = Shaped::default();
|
||||
let mut points_left = ttf::MAX_SHAPED_POINTS;
|
||||
let mut spans: Vec<(f64, f64, bool, bool)> = Vec::new();
|
||||
let mut x = 0.0;
|
||||
let mut pen_x = 0.0;
|
||||
// Whether the rightmost glyph so far is a stroke-font glyph.
|
||||
let mut stroke_last = false;
|
||||
for (run, rtl) in bidi::visual_runs(&cs, base_rtl) {
|
||||
let mut pieces = itemize(&cs, run, primary);
|
||||
for (run, rtl) in bidi::visual_runs(&characters, base_rtl) {
|
||||
let mut pieces = itemize(&characters, run, primary);
|
||||
if rtl {
|
||||
pieces.reverse();
|
||||
}
|
||||
for (src, r) in pieces {
|
||||
for (src, range) in pieces {
|
||||
match &src {
|
||||
Src::Hidden => {}
|
||||
Src::Stroke | Src::Missing => {
|
||||
let idx: Vec<usize> = if rtl { r.rev().collect() } else { r.collect() };
|
||||
for i in idx {
|
||||
let c = cs.get(i).copied().unwrap_or(' ');
|
||||
let c = if rtl { bidi::mirror(c) } else { c };
|
||||
match (&src, stroke::glyph(c)) {
|
||||
(Src::Stroke, Some((_, spec))) => crate::draw_stroke_glyph(&mut out, spec, x, sc, wf, shear),
|
||||
(Src::Missing, _) => crate::missing_glyph_box(&mut out, x, h, sc * wf),
|
||||
let indices: Vec<usize> = if rtl { range.rev().collect() } else { range.collect() };
|
||||
for index in indices {
|
||||
let character = characters.get(index).copied().unwrap_or(' ');
|
||||
let character = if rtl { bidi::mirror(character) } else { character };
|
||||
match (&src, stroke::glyph(character)) {
|
||||
(Src::Stroke, Some((_, spec))) => {
|
||||
crate::draw_stroke_glyph(&mut shaped, spec, pen_x, stroke_scale, scale_x, shear);
|
||||
}
|
||||
(Src::Missing, _) => crate::missing_glyph_box(&mut shaped, pen_x, normalized_height, stroke_scale * scale_x),
|
||||
_ => {}
|
||||
}
|
||||
let adv = crate::char_advance(c) * h * wf;
|
||||
let (u, o) = flags(i);
|
||||
spans.push((x, x + adv, u, o));
|
||||
x += adv;
|
||||
let advance = crate::char_advance(character) * normalized_height * scale_x;
|
||||
let (underline, overline) = flags(index);
|
||||
spans.push((pen_x, pen_x + advance, underline, overline));
|
||||
pen_x += advance;
|
||||
stroke_last = true;
|
||||
}
|
||||
}
|
||||
Src::Face(face) => {
|
||||
let glyphs = shape_run(face, &cs, r.clone(), rtl);
|
||||
let glyphs = shape_run(face, &characters, range.clone(), rtl);
|
||||
// Right-to-left runs stay outlines only: their glyphs come in display order
|
||||
// and include ligatures (lam-alef) that stand for several characters.
|
||||
let shows = if rtl { Vec::new() } else { glyph_chars(face, &cs, &glyphs, r.end) };
|
||||
for (n, g) in glyphs.iter().enumerate() {
|
||||
let outline = ttf::glyph_by_id(face, g.gid);
|
||||
let k = h / outline.cap * wf;
|
||||
let dy = g.dy * h / outline.cap;
|
||||
if let Some(mut contours) = ttf::place_glyph_budgeted(&outline, x + g.dx * k, h, wf, shear, &mut points_left) {
|
||||
for p in contours.iter_mut().flatten() {
|
||||
*p += Vec2::new(dy * shear, dy);
|
||||
let shows = if rtl { Vec::new() } else { glyph_chars(face, &characters, &glyphs, range.end) };
|
||||
for (n, glyph) in glyphs.iter().enumerate() {
|
||||
let outline = ttf::glyph_by_id(face, glyph.gid);
|
||||
let glyph_scale = normalized_height / outline.cap * scale_x;
|
||||
let offset_y = glyph.dy * normalized_height / outline.cap;
|
||||
if let Some(mut contours) =
|
||||
ttf::place_glyph_budgeted(&outline, pen_x + glyph.dx * glyph_scale, normalized_height, scale_x, shear, &mut points_left)
|
||||
{
|
||||
for point in contours.iter_mut().flatten() {
|
||||
*point += Vec2::new(offset_y * shear, offset_y);
|
||||
}
|
||||
let origin = Vec2::new(x + g.dx * k + dy * shear, dy);
|
||||
let text = shows
|
||||
.get(n)
|
||||
.copied()
|
||||
.flatten()
|
||||
.filter(|c| !c.is_whitespace())
|
||||
.and_then(|c| ttf::text_glyph_at(&outline, c, origin, h / outline.cap, wf, shear));
|
||||
out.push_glyph(contours, text);
|
||||
let origin = Vec2::new(pen_x + glyph.dx * glyph_scale + offset_y * shear, offset_y);
|
||||
let text = shows.get(n).copied().flatten().filter(|character| !character.is_whitespace()).and_then(|character| {
|
||||
ttf::text_glyph_at(&outline, character, origin, normalized_height / outline.cap, scale_x, shear)
|
||||
});
|
||||
shaped.push_glyph(contours, text);
|
||||
}
|
||||
let adv = g.advance * k;
|
||||
let (u, o) = flags(g.cluster);
|
||||
spans.push((x, x + adv, u, o));
|
||||
x += adv;
|
||||
let advance = glyph.advance * glyph_scale;
|
||||
let (underline, overline) = flags(glyph.cluster);
|
||||
spans.push((pen_x, pen_x + advance, underline, overline));
|
||||
pen_x += advance;
|
||||
stroke_last = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
out.strokes.extend(crate::decorations(&spans, h));
|
||||
shaped.strokes.extend(crate::decorations(&spans, normalized_height));
|
||||
// A stroke-font glyph at the right end: the width leaves out its trailing gap, like
|
||||
// `shape_stroke`.
|
||||
out.width = if stroke_last { (x - stroke::GAP * sc * wf).max(0.0) } else { x };
|
||||
out
|
||||
shaped.width = if stroke_last { (pen_x - stroke::GAP * stroke_scale * scale_x).max(0.0) } else { pen_x };
|
||||
shaped
|
||||
}
|
||||
|
||||
/// Split a logical-order run into pieces by what draws each character. Joiners and combining
|
||||
@@ -333,7 +334,7 @@ mod tests {
|
||||
assert!(shaped.text.is_empty());
|
||||
|
||||
let underlined = shape(Some(&face), "%%u ", 1.0, 1.0, 0.0, None).expect("shapes decorated empty glyph");
|
||||
assert_eq!(underlined.width, shaped.width);
|
||||
assert!((underlined.width - shaped.width).abs() < f64::EPSILON);
|
||||
assert!(underlined.glyphs.is_empty());
|
||||
assert!(underlined.text.is_empty());
|
||||
assert!(!underlined.strokes.is_empty(), "decoration spans survive an empty outline");
|
||||
@@ -350,7 +351,7 @@ mod tests {
|
||||
assert!((crate::line_width(s, 1.0, 1.0) - sh.width).abs() < 1e-9);
|
||||
let digits: Vec<f64> = sh.strokes.iter().filter(|st| !(st.len() == 5 && st.first() == st.last())).flatten().map(|p| p.x).collect();
|
||||
assert!(!digits.is_empty());
|
||||
let (lo, hi) = (digits.iter().cloned().fold(f64::MAX, f64::min), digits.iter().cloned().fold(f64::MIN, f64::max));
|
||||
let (lo, hi) = (digits.iter().copied().fold(f64::MAX, f64::min), digits.iter().copied().fold(f64::MIN, f64::max));
|
||||
assert!(lo > 0.2 * sh.width && hi < 0.8 * sh.width, "digits between the words: {lo}..{hi} of {}", sh.width);
|
||||
}
|
||||
|
||||
@@ -382,7 +383,7 @@ mod tests {
|
||||
|
||||
fn nominal(f: &Face, c: char) -> Option<u32> {
|
||||
use skrifa::MetadataProvider;
|
||||
f.font().and_then(|font| font.charmap().map(c)).map(|g| g.to_u32())
|
||||
f.font().and_then(|font| font.charmap().map(c)).map(skrifa::GlyphId::to_u32)
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -407,7 +408,7 @@ mod tests {
|
||||
assert!(!sh.strokes.iter().any(|s| s.len() == 5 && s.first() == s.last()), "no missing-glyph boxes");
|
||||
// The ASCII digits are stroke glyphs in the middle of the line.
|
||||
let stroke_x: Vec<f64> = sh.strokes.iter().flatten().map(|p| p.x).collect();
|
||||
let (lo, hi) = (stroke_x.iter().cloned().fold(f64::MAX, f64::min), stroke_x.iter().cloned().fold(f64::MIN, f64::max));
|
||||
let (lo, hi) = (stroke_x.iter().copied().fold(f64::MAX, f64::min), stroke_x.iter().copied().fold(f64::MIN, f64::max));
|
||||
assert!(lo > 0.2 * sh.width && hi < 0.8 * sh.width, "digits between the words: {lo}..{hi} of {}", sh.width);
|
||||
assert!((crate::line_width("قیمت 25 تومان", 1.0, 1.0) - sh.width).abs() < 1e-9);
|
||||
}
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
//! Fonts from the optional craft-fonts build input (<https://github.com/storytold/craft-fonts>).
|
||||
//!
|
||||
//! Built with `CRAFT_FONTS_DIR=<craft-fonts checkout>`, `build.rs` embeds the fonts listed in its
|
||||
//! `fonts/manifest.txt` (web builds: only BIZ UDPGothic Regular, the Arabic and Georgian faces and
|
||||
//! `fonts/manifest.txt` (web builds: only `BIZ UDPGothic` Regular, the `Arab` and `Geor` faces and
|
||||
//! the Thai Regular faces). Without it [`CRAFT_FONTS`] is empty and nothing changes. The font table ([`crate::ttf`])
|
||||
//! lists the embedded fonts with the installed ones, under [`CraftFont::stem`]. A text style
|
||||
//! can name one (`BIZ UDPGothic`), and they are fallbacks for characters a text's font lacks.
|
||||
|
||||
+65
-62
@@ -46,24 +46,24 @@ pub struct Run {
|
||||
/// Replace `%%` control codes: `%%d` degree, `%%p` plus/minus, `%%c` diameter, `%%%` percent,
|
||||
/// `%%nnn` character code, and `\U+XXXX` Unicode escapes. Underline/overline toggles (`%%u`,
|
||||
/// `%%o`) are returned as flags per character.
|
||||
pub fn decode_controls(s: &str) -> Vec<(char, bool, bool)> {
|
||||
let mut out = Vec::with_capacity(s.len());
|
||||
pub fn decode_controls(text: &str) -> Vec<(char, bool, bool)> {
|
||||
let mut out = Vec::with_capacity(text.len());
|
||||
let mut under = false;
|
||||
let mut over = false;
|
||||
let chars: Vec<char> = s.chars().collect();
|
||||
let mut i = 0;
|
||||
while i < chars.len() {
|
||||
let c = chars.get(i).copied().unwrap_or(' ');
|
||||
let chars: Vec<char> = text.chars().collect();
|
||||
let mut index = 0;
|
||||
while index < chars.len() {
|
||||
let character = chars.get(index).copied().unwrap_or(' ');
|
||||
// `\U+XXXX`: a Unicode character by its code.
|
||||
if c == '\\'
|
||||
&& let Some(u) = unicode_escape(&chars, i)
|
||||
if character == '\\'
|
||||
&& let Some(u) = unicode_escape(&chars, index)
|
||||
{
|
||||
out.push((u, under, over));
|
||||
i += 7;
|
||||
index += 7;
|
||||
continue;
|
||||
}
|
||||
if c == '%' && chars.get(i + 1) == Some(&'%') {
|
||||
let code = chars.get(i + 2).copied().unwrap_or(' ');
|
||||
if character == '%' && chars.get(index + 1) == Some(&'%') {
|
||||
let code = chars.get(index + 2).copied().unwrap_or(' ');
|
||||
match code.to_ascii_lowercase() {
|
||||
'd' => out.push(('°', under, over)),
|
||||
'p' => out.push(('±', under, over)),
|
||||
@@ -71,24 +71,24 @@ pub fn decode_controls(s: &str) -> Vec<(char, bool, bool)> {
|
||||
'%' => out.push(('%', under, over)),
|
||||
'u' => under = !under,
|
||||
'o' => over = !over,
|
||||
d if d.is_ascii_digit() => {
|
||||
let digits: String = chars.iter().skip(i + 2).take(3).take_while(|c| c.is_ascii_digit()).collect();
|
||||
let n: u32 = digits.parse().unwrap_or(32);
|
||||
out.push((char::from_u32(n).unwrap_or('?'), under, over));
|
||||
i += 2 + digits.len();
|
||||
digit if digit.is_ascii_digit() => {
|
||||
let digits: String = chars.iter().skip(index + 2).take(3).take_while(|character| character.is_ascii_digit()).collect();
|
||||
let codepoint: u32 = digits.parse().unwrap_or(32);
|
||||
out.push((char::from_u32(codepoint).unwrap_or('?'), under, over));
|
||||
index += 2 + digits.len();
|
||||
continue;
|
||||
}
|
||||
_ => {
|
||||
out.push(('%', under, over));
|
||||
i += 1;
|
||||
index += 1;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
i += 3;
|
||||
index += 3;
|
||||
continue;
|
||||
}
|
||||
out.push((c, under, over));
|
||||
i += 1;
|
||||
out.push((character, under, over));
|
||||
index += 1;
|
||||
}
|
||||
out
|
||||
}
|
||||
@@ -174,81 +174,84 @@ pub fn shape_stroke(s: &str, height: f64, width_factor: f64, oblique: f64) -> Sh
|
||||
|
||||
/// [`shape_stroke`] in the direction `base_rtl` (`None`: that of the line's first strong
|
||||
/// character).
|
||||
pub fn shape_stroke_dir(s: &str, height: f64, width_factor: f64, oblique: f64, base_rtl: Option<bool>) -> Shaped {
|
||||
let h = if height.is_finite() && height > 0.0 { height } else { 1.0 };
|
||||
let wf = if width_factor.is_finite() && width_factor.abs() > 1e-6 { width_factor } else { 1.0 };
|
||||
let sc = h / stroke::CAP;
|
||||
pub fn shape_stroke_dir(text: &str, height: f64, width_factor: f64, oblique: f64, base_rtl: Option<bool>) -> Shaped {
|
||||
let normalized_height = if height.is_finite() && height > 0.0 { height } else { 1.0 };
|
||||
let scale_x = if width_factor.is_finite() && width_factor.abs() > 1e-6 { width_factor } else { 1.0 };
|
||||
let stroke_scale = normalized_height / stroke::CAP;
|
||||
let shear = oblique.tan().clamp(-10.0, 10.0);
|
||||
let mut out = Shaped::default();
|
||||
let mut x = 0.0;
|
||||
let mut pen_x = 0.0;
|
||||
let mut under_start: Option<f64> = None;
|
||||
let mut over_start: Option<f64> = None;
|
||||
let mut gap = stroke::GAP * sc * wf;
|
||||
let mut gap = stroke::GAP * stroke_scale * scale_x;
|
||||
// Retained fallback-outline points over the line, as the TrueType path caps them: a short string
|
||||
// repeating one detailed glyph would otherwise copy its outline per occurrence.
|
||||
let mut points_left = ttf::MAX_SHAPED_POINTS;
|
||||
// The simple path lays a line out left to right: one asked to run right to left goes through
|
||||
// the bidi path even without right-to-left letters.
|
||||
if (complex::needed(s) || base_rtl == Some(true))
|
||||
&& let Some(sh) = complex::shape(None, s, h, wf, oblique, base_rtl)
|
||||
if (complex::needed(text) || base_rtl == Some(true))
|
||||
&& let Some(sh) = complex::shape(None, text, normalized_height, scale_x, oblique, base_rtl)
|
||||
{
|
||||
return sh;
|
||||
}
|
||||
for (c, under, over) in decode_controls(s) {
|
||||
if bidi::is_format_control(c) {
|
||||
for (character, under, over) in decode_controls(text) {
|
||||
if bidi::is_format_control(character) {
|
||||
continue;
|
||||
}
|
||||
let mut adv = char_advance(c) * h * wf;
|
||||
gap = stroke::GAP * sc * wf;
|
||||
match stroke::glyph(c) {
|
||||
Some((_, spec)) => draw_stroke_glyph(&mut out, spec, x, sc, wf, shear),
|
||||
None if !c.is_whitespace() => match ttf::fallback_glyph(c) {
|
||||
Some(g) => {
|
||||
let (y, scale) = stroke_fallback_metrics(&g, c, h);
|
||||
let contours = match points_left.checked_sub(g.points) {
|
||||
let mut adv = char_advance(character) * normalized_height * scale_x;
|
||||
gap = stroke::GAP * stroke_scale * scale_x;
|
||||
match stroke::glyph(character) {
|
||||
Some((_, spec)) => draw_stroke_glyph(&mut out, spec, pen_x, stroke_scale, scale_x, shear),
|
||||
None if !character.is_whitespace() => match ttf::fallback_glyph(character) {
|
||||
Some(glyph) => {
|
||||
let (origin_y, scale) = stroke_fallback_metrics(&glyph, character, normalized_height);
|
||||
let contours = match points_left.checked_sub(glyph.points) {
|
||||
Some(rest) => {
|
||||
points_left = rest;
|
||||
ttf::place_glyph_at(&g, Vec2::new(x, y), scale, wf, shear)
|
||||
ttf::place_glyph_at(&glyph, Vec2::new(pen_x, origin_y), scale, scale_x, shear)
|
||||
}
|
||||
None => Vec::new(),
|
||||
};
|
||||
if !contours.is_empty() {
|
||||
out.push_glyph(contours, ttf::text_glyph_at(&g, c, Vec2::new(x + y * shear, y), scale, wf, shear));
|
||||
out.push_glyph(
|
||||
contours,
|
||||
ttf::text_glyph_at(&glyph, character, Vec2::new(pen_x + origin_y * shear, origin_y), scale, scale_x, shear),
|
||||
);
|
||||
}
|
||||
adv = g.advance * scale * wf;
|
||||
adv = glyph.advance * scale * scale_x;
|
||||
gap = 0.0;
|
||||
}
|
||||
None => missing_glyph_box(&mut out, x, h, sc * wf),
|
||||
None => missing_glyph_box(&mut out, pen_x, normalized_height, stroke_scale * scale_x),
|
||||
},
|
||||
None => {}
|
||||
}
|
||||
// Decorations.
|
||||
match (under, under_start) {
|
||||
(true, None) => under_start = Some(x),
|
||||
(true, None) => under_start = Some(pen_x),
|
||||
(false, Some(sx)) => {
|
||||
out.strokes.push(vec![Vec2::new(sx, -h * 0.2), Vec2::new(x, -h * 0.2)]);
|
||||
out.strokes.push(vec![Vec2::new(sx, -normalized_height * 0.2), Vec2::new(pen_x, -normalized_height * 0.2)]);
|
||||
under_start = None;
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
match (over, over_start) {
|
||||
(true, None) => over_start = Some(x),
|
||||
(true, None) => over_start = Some(pen_x),
|
||||
(false, Some(sx)) => {
|
||||
out.strokes.push(vec![Vec2::new(sx, h * 1.2), Vec2::new(x, h * 1.2)]);
|
||||
out.strokes.push(vec![Vec2::new(sx, normalized_height * 1.2), Vec2::new(pen_x, normalized_height * 1.2)]);
|
||||
over_start = None;
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
x += adv;
|
||||
pen_x += adv;
|
||||
}
|
||||
// The stroke font's gap after the last character isn't part of the line; a fallback glyph
|
||||
// has none.
|
||||
let end = (x - gap).max(0.0);
|
||||
let end = (pen_x - gap).max(0.0);
|
||||
if let Some(sx) = under_start {
|
||||
out.strokes.push(vec![Vec2::new(sx, -h * 0.2), Vec2::new(end, -h * 0.2)]);
|
||||
out.strokes.push(vec![Vec2::new(sx, -normalized_height * 0.2), Vec2::new(end, -normalized_height * 0.2)]);
|
||||
}
|
||||
if let Some(sx) = over_start {
|
||||
out.strokes.push(vec![Vec2::new(sx, h * 1.2), Vec2::new(end, h * 1.2)]);
|
||||
out.strokes.push(vec![Vec2::new(sx, normalized_height * 1.2), Vec2::new(end, normalized_height * 1.2)]);
|
||||
}
|
||||
out.width = end;
|
||||
out
|
||||
@@ -360,7 +363,7 @@ impl TextFont {
|
||||
if builtin {
|
||||
return TextFont::Stroke;
|
||||
}
|
||||
ttf::find(alt_main).map(TextFont::Outline).unwrap_or(TextFont::Stroke)
|
||||
ttf::find(alt_main).map_or(TextFont::Stroke, TextFont::Outline)
|
||||
}
|
||||
pub fn is_outline(&self) -> bool {
|
||||
matches!(self, TextFont::Outline(_))
|
||||
@@ -503,7 +506,7 @@ pub fn shape_line_dir(font: &TextFont, s: &str, height: f64, width_factor: f64,
|
||||
shape_stroke_dir(s, height, width_factor, oblique, base_rtl)
|
||||
}
|
||||
|
||||
/// Single-line TEXT (and attributes) runs left to right, as AutoCAD lays it out: neutral
|
||||
/// Single-line TEXT (and attributes) runs left to right, as `AutoCAD` lays it out: neutral
|
||||
/// characters before a right-to-left word ("- " in "- פרוייקט") stay on its left (#2500).
|
||||
const TEXT_BASE_RTL: Option<bool> = Some(false);
|
||||
|
||||
@@ -591,7 +594,7 @@ pub fn baseline_start(font: &TextFont, s: &str, p: &TextParams) -> Vec2 {
|
||||
}
|
||||
|
||||
/// How far below the baseline a bottom-justified text's alignment point lies: a third of the
|
||||
/// height for the stroke font (as AutoCAD places it with SHX fonts), the face's descent for an
|
||||
/// height for the stroke font (as `AutoCAD` places it with SHX fonts), the face's descent for an
|
||||
/// outline font (#2229).
|
||||
fn bottom_depth(font: &TextFont, height: f64) -> f64 {
|
||||
match font {
|
||||
@@ -602,12 +605,12 @@ fn bottom_depth(font: &TextFont, height: f64) -> f64 {
|
||||
}
|
||||
|
||||
/// The vertical middle of shaped text's ink (its strokes and outlines), above the baseline;
|
||||
/// `None` when it draws nothing. A Middle (M) text is centred there: AutoCAD centres it on the
|
||||
/// `None` when it draws nothing. A Middle (M) text is centred there: `AutoCAD` centres it on the
|
||||
/// string's own extents, descenders included, not at half the height (#2229).
|
||||
fn ink_middle(sh: &Shaped) -> Option<f64> {
|
||||
let ys = sh.strokes.iter().flatten().chain(sh.glyphs.iter().flatten().flatten()).map(|q| q.y).filter(|y| y.is_finite());
|
||||
let (lo, hi) = ys.fold((f64::INFINITY, f64::NEG_INFINITY), |(lo, hi), y| (lo.min(y), hi.max(y)));
|
||||
(lo <= hi).then_some((lo + hi) / 2.0)
|
||||
(lo <= hi).then_some(f64::midpoint(lo, hi))
|
||||
}
|
||||
|
||||
/// The offset of a line's baseline start from its alignment point, for justification `h`/`v`.
|
||||
@@ -714,7 +717,7 @@ mod tests {
|
||||
use super::*;
|
||||
|
||||
/// A TEXT that starts with neutral characters before a Hebrew word ("- פרוייקט") keeps them
|
||||
/// on the left, as AutoCAD draws it; the line's own direction (first strong character) would
|
||||
/// on the left, as `AutoCAD` draws it; the line's own direction (first strong character) would
|
||||
/// put the dash on the right (#2500).
|
||||
#[test]
|
||||
fn text_runs_left_to_right_whatever_its_first_strong_character() {
|
||||
@@ -942,7 +945,7 @@ mod justify_tests {
|
||||
ys.fold((f64::INFINITY, f64::NEG_INFINITY), |(lo, hi), y| (lo.min(y), hi.max(y)))
|
||||
}
|
||||
|
||||
/// A Middle (M) text is centred on its own ink, descenders included, as AutoCAD centres it,
|
||||
/// A Middle (M) text is centred on its own ink, descenders included, as `AutoCAD` centres it,
|
||||
/// not at half the height: lowercase and descenders move the baseline (#2229).
|
||||
#[test]
|
||||
fn a_middle_text_is_centred_on_its_ink() {
|
||||
@@ -951,11 +954,11 @@ mod justify_tests {
|
||||
for s in ["ABC 123", "gjpqy", "Tg 1234 ABC", "ace"] {
|
||||
let (sh, start) = placed(&font, s, Align::Middle, VAlign::Baseline);
|
||||
let (lo, hi) = ink_y(&sh);
|
||||
assert!(((lo + hi) / 2.0).abs() < 1e-9, "{s}: ink {lo}..{hi} is centred on the alignment point");
|
||||
assert!((f64::midpoint(lo, hi)).abs() < 1e-9, "{s}: ink {lo}..{hi} is centred on the alignment point");
|
||||
// The insertion point a DWG keeps (group 10) is the baseline start, below the ink's
|
||||
// middle by as much as the unplaced text's ink middle is above its baseline.
|
||||
let (lo0, hi0) = ink_y(&shape_line(&font, s, H, 1.0, 0.0));
|
||||
assert!((start.y + (lo0 + hi0) / 2.0).abs() < 1e-9, "{s}: baseline start {start:?}");
|
||||
assert!((start.y + f64::midpoint(lo0, hi0)).abs() < 1e-9, "{s}: baseline start {start:?}");
|
||||
baselines.push((s, start.y));
|
||||
}
|
||||
// Capitals and digits span the height, so they stay at half of it.
|
||||
@@ -975,7 +978,7 @@ mod justify_tests {
|
||||
assert!((start.y + H / 2.0).abs() < 1e-9, "{start:?}");
|
||||
}
|
||||
|
||||
/// With the stroke font (as with AutoCAD's SHX fonts), a bottom-justified text's baseline is
|
||||
/// With the stroke font (as with `AutoCAD`'s SHX fonts), a bottom-justified text's baseline is
|
||||
/// a third of the height above its alignment point, and Middle Center still uses half.
|
||||
#[test]
|
||||
fn stroke_font_bottom_and_middle_center_are_unchanged() {
|
||||
@@ -989,7 +992,7 @@ mod justify_tests {
|
||||
}
|
||||
|
||||
/// With a TrueType font, a bottom-justified text's alignment point is at the face's descent,
|
||||
/// where its descenders end, as AutoCAD places it (#2229: Arial's is 0.296 of the height).
|
||||
/// where its descenders end, as `AutoCAD` places it (#2229: Arial's is 0.296 of the height).
|
||||
/// Uses the first of these common fonts that is installed (Windows, macOS and Linux each have
|
||||
/// one); skips without any.
|
||||
#[test]
|
||||
@@ -1009,6 +1012,6 @@ mod justify_tests {
|
||||
// And Middle centres the ink, as with the stroke font.
|
||||
let (sh, _) = placed(&font, "Tg 1234 ABC", Align::Middle, VAlign::Baseline);
|
||||
let (lo, hi) = ink_y(&sh);
|
||||
assert!(((lo + hi) / 2.0).abs() < 1e-9, "{name}: {lo}..{hi}");
|
||||
assert!((f64::midpoint(lo, hi)).abs() < 1e-9, "{name}: {lo}..{hi}");
|
||||
}
|
||||
}
|
||||
|
||||
+39
-41
@@ -19,11 +19,7 @@ pub fn plain_mtext(s: &str) -> String {
|
||||
'\\' => {
|
||||
let code = chars.get(i + 1).copied().unwrap_or(' ');
|
||||
match code {
|
||||
'P' => {
|
||||
out.push('\n');
|
||||
i += 2;
|
||||
}
|
||||
'N' => {
|
||||
'P' | 'N' => {
|
||||
out.push('\n');
|
||||
i += 2;
|
||||
}
|
||||
@@ -79,8 +75,7 @@ pub fn plain_mtext(s: &str) -> String {
|
||||
_ => i += 2,
|
||||
}
|
||||
}
|
||||
'{' | '}' => i += 1,
|
||||
'\r' => i += 1,
|
||||
'{' | '}' | '\r' => i += 1,
|
||||
_ => {
|
||||
out.push(c);
|
||||
i += 1;
|
||||
@@ -357,6 +352,10 @@ fn font_switch(a: &str) -> Option<TextFont> {
|
||||
}
|
||||
|
||||
/// Parse MTEXT contents into words, spaces and paragraph breaks with their formats.
|
||||
#[expect(
|
||||
clippy::too_many_lines,
|
||||
reason = "The MTEXT escape grammar is one cohesive state machine; its ordered transitions are clearer in a single dispatch."
|
||||
)]
|
||||
fn parse(contents: &str, base: Fmt) -> (Vec<Atom>, Vec<Fmt>) {
|
||||
let chars: Vec<char> = contents.chars().collect();
|
||||
let h_min = base.height * 1e-3;
|
||||
@@ -634,56 +633,56 @@ fn seg_width(seg: &Seg, f: &Fmt) -> f64 {
|
||||
}
|
||||
|
||||
/// Shape a segment with its left end at `x` on the baseline.
|
||||
fn seg_shape(seg: &Seg, f: &Fmt, x: f64) -> Shaped {
|
||||
let h = f.height;
|
||||
fn seg_shape(seg: &Seg, format: &Fmt, origin_x: f64) -> Shaped {
|
||||
let height = format.height;
|
||||
let mut out = Shaped::default();
|
||||
let put = |s: &str, size: f64, at: Vec2| {
|
||||
if s.is_empty() {
|
||||
let put = |text: &str, size: f64, at: Vec2| {
|
||||
if text.is_empty() {
|
||||
return Shaped::default();
|
||||
}
|
||||
let mut sh = shape_line(&f.font, s, size, f.wf, f.oblique);
|
||||
sh.map(|p| p + at);
|
||||
let mut sh = shape_line(&format.font, text, size, format.wf, format.oblique);
|
||||
sh.map(|point| point + at);
|
||||
sh
|
||||
};
|
||||
let w = seg_width(seg, f);
|
||||
let width = seg_width(seg, format);
|
||||
match seg {
|
||||
Seg::Text(t) => out.extend(put(t, h, Vec2::new(x, 0.0))),
|
||||
Seg::Text(text) => out.extend(put(text, height, Vec2::new(origin_x, 0.0))),
|
||||
Seg::Stack(top, bottom, sep) => {
|
||||
let hs = h * STACK_SCALE;
|
||||
let wt = text_width(&f.font, top, hs, f.wf);
|
||||
let wb = text_width(&f.font, bottom, hs, f.wf);
|
||||
let hs = height * STACK_SCALE;
|
||||
let wt = text_width(&format.font, top, hs, format.wf);
|
||||
let wb = text_width(&format.font, bottom, hs, format.wf);
|
||||
match sep {
|
||||
'#' => {
|
||||
out.extend(put(top, hs, Vec2::new(x, h * 0.4)));
|
||||
let sx = x + wt + h * 0.1;
|
||||
out.extend(put(bottom, hs, Vec2::new(sx + h * 0.4, -h * 0.05)));
|
||||
out.strokes.push(vec![Vec2::new(sx, -h * 0.1), Vec2::new(sx + h * 0.3, h * 1.1)]);
|
||||
out.extend(put(top, hs, Vec2::new(origin_x, height * 0.4)));
|
||||
let sx = origin_x + wt + height * 0.1;
|
||||
out.extend(put(bottom, hs, Vec2::new(sx + height * 0.4, -height * 0.05)));
|
||||
out.strokes.push(vec![Vec2::new(sx, -height * 0.1), Vec2::new(sx + height * 0.3, height * 1.1)]);
|
||||
}
|
||||
'^' => {
|
||||
// Tolerances: centred on the line, or the lower value on the baseline (\A0) or
|
||||
// the upper value level with the text (\A2).
|
||||
let (yt, yb) = match f.valign {
|
||||
0 => (hs + h * 0.1, 0.0),
|
||||
2 => (0.0, -hs - h * 0.1),
|
||||
_ => (h * 0.55, h * 0.45 - hs),
|
||||
let (yt, yb) = match format.valign {
|
||||
0 => (hs + height * 0.1, 0.0),
|
||||
2 => (0.0, -hs - height * 0.1),
|
||||
_ => (height * 0.55, height * 0.45 - hs),
|
||||
};
|
||||
out.extend(put(top, hs, Vec2::new(x, yt)));
|
||||
out.extend(put(bottom, hs, Vec2::new(x, yb)));
|
||||
out.extend(put(top, hs, Vec2::new(origin_x, yt)));
|
||||
out.extend(put(bottom, hs, Vec2::new(origin_x, yb)));
|
||||
}
|
||||
_ => {
|
||||
let bar = h * 0.45;
|
||||
out.extend(put(top, hs, Vec2::new(x + (w - wt) / 2.0, bar + h * 0.12)));
|
||||
out.extend(put(bottom, hs, Vec2::new(x + (w - wb) / 2.0, bar - h * 0.12 - hs)));
|
||||
out.strokes.push(vec![Vec2::new(x, bar), Vec2::new(x + w, bar)]);
|
||||
let bar = height * 0.45;
|
||||
out.extend(put(top, hs, Vec2::new(origin_x + (width - wt) / 2.0, bar + height * 0.12)));
|
||||
out.extend(put(bottom, hs, Vec2::new(origin_x + (width - wb) / 2.0, bar - height * 0.12 - hs)));
|
||||
out.strokes.push(vec![Vec2::new(origin_x, bar), Vec2::new(origin_x + width, bar)]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if f.under {
|
||||
out.strokes.push(vec![Vec2::new(x, -h * 0.2), Vec2::new(x + w, -h * 0.2)]);
|
||||
if format.under {
|
||||
out.strokes.push(vec![Vec2::new(origin_x, -height * 0.2), Vec2::new(origin_x + width, -height * 0.2)]);
|
||||
}
|
||||
if f.over {
|
||||
out.strokes.push(vec![Vec2::new(x, h * 1.2), Vec2::new(x + w, h * 1.2)]);
|
||||
if format.over {
|
||||
out.strokes.push(vec![Vec2::new(origin_x, height * 1.2), Vec2::new(origin_x + width, height * 1.2)]);
|
||||
}
|
||||
out
|
||||
}
|
||||
@@ -791,8 +790,7 @@ fn plain_lines(atoms: &[Atom], fmts: &[Fmt], base: &Fmt, width: f64) -> Vec<Line
|
||||
};
|
||||
for segments in pieces {
|
||||
let word_width = word_width(segments);
|
||||
let space_width =
|
||||
pending_space.map(|format| crate::space_width(&fmt(format).font, fmt(format).height, fmt(format).wf)).unwrap_or(0.0);
|
||||
let space_width = pending_space.map_or(0.0, |format| crate::space_width(&fmt(format).font, fmt(format).height, fmt(format).wf));
|
||||
if width > 0.0 && !line.items.is_empty() && line.width + space_width + word_width > width + 1e-9 {
|
||||
finish(&mut lines, &mut line, fmt(last_fmt), paragraph);
|
||||
} else if !line.items.is_empty() || pending_space.is_some() {
|
||||
@@ -1120,7 +1118,7 @@ mod tests {
|
||||
let cols: Vec<Option<MTextColor>> = l.pieces.iter().map(|p| p.color).collect();
|
||||
assert_eq!(cols, vec![None, Some(MTextColor::Aci(1)), None]);
|
||||
let l = lay("\\c16711680;R", 0.0);
|
||||
assert_eq!(l.pieces.first().map(|p| p.color), Some(Some(MTextColor::Rgb(0xFF0000))));
|
||||
assert_eq!(l.pieces.first().map(|p| p.color), Some(Some(MTextColor::Rgb(0x00FF_0000))));
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -1142,8 +1140,8 @@ mod tests {
|
||||
let bar = l.strokes.iter().find(|s| s.len() == 2 && (s[0].y - s[1].y).abs() < 1e-12 && (s[0].y + 0.55).abs() < 1e-9);
|
||||
assert!(bar.is_some());
|
||||
let ys: Vec<f64> = l.strokes.iter().flatten().map(|p| p.y).collect();
|
||||
let max = ys.iter().cloned().fold(f64::MIN, f64::max);
|
||||
let min = ys.iter().cloned().fold(f64::MAX, f64::min);
|
||||
let max = ys.iter().copied().fold(f64::MIN, f64::max);
|
||||
let min = ys.iter().copied().fold(f64::MAX, f64::min);
|
||||
assert!(max > 0.0 && min < -1.0, "{min}..{max}");
|
||||
// Narrower than the two digits side by side at full size.
|
||||
assert!(l.bounds.width() < crate::line_width("12", 1.0, 1.0));
|
||||
|
||||
@@ -57,7 +57,7 @@ pub enum ParaAlign {
|
||||
}
|
||||
|
||||
/// Paragraph properties set by `\p…;`. Indents and tab stops are in drawing units (as in
|
||||
/// AutoCAD files: `\pi4.86;` indents the first line by 4.86 units), space before and after in
|
||||
/// `AutoCAD` files: `\pi4.86;` indents the first line by 4.86 units), space before and after in
|
||||
/// text heights. They stay in effect for the following paragraphs until another `\p` changes them.
|
||||
#[derive(Clone, Debug, Default, PartialEq)]
|
||||
pub struct ParaProps {
|
||||
@@ -226,7 +226,7 @@ impl ListStyle {
|
||||
let mut s = Vec::new();
|
||||
while n > 0 && s.len() < 16 {
|
||||
n -= 1;
|
||||
let c = b'a' + (n % 26) as u8;
|
||||
let c = b'a' + u8::try_from(n % 26).unwrap_or(0);
|
||||
s.push(char::from(if upper { c.to_ascii_uppercase() } else { c }));
|
||||
n /= 26;
|
||||
}
|
||||
@@ -544,9 +544,7 @@ impl<'a> LineBuilder<'a> {
|
||||
fn place(&mut self, index: usize, segments: &[(Seg, usize)]) {
|
||||
let word_width = self.word_width(segments);
|
||||
let space_width = if index == 0 {
|
||||
self.pending_space
|
||||
.map(|format| crate::space_width(&self.format(format).font, self.format(format).height, self.format(format).wf))
|
||||
.unwrap_or(0.0)
|
||||
self.pending_space.map_or(0.0, |format| crate::space_width(&self.format(format).font, self.format(format).height, self.format(format).wf))
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
@@ -596,72 +594,80 @@ fn next_tab(x: f64, pp: &ParaProps, h: f64) -> (f64, TabKind) {
|
||||
}
|
||||
|
||||
/// Lay out MTEXT with paragraph formatting and columns. `base` is the entity's own format,
|
||||
/// `h` its text height, `width` the column width (0: no wrapping, no columns).
|
||||
pub(super) fn layout(contents: &str, p: &MTextParams, base: &Fmt) -> MTextLayout {
|
||||
let h = base.height;
|
||||
let width = if p.width.is_finite() && p.width > 0.0 { p.width } else { 0.0 };
|
||||
let rotation = if p.rotation.is_finite() { p.rotation } else { 0.0 };
|
||||
let paras = Paragraphs::scan(contents);
|
||||
/// `height` its text height, `width` the column width (0: no wrapping, no columns).
|
||||
#[expect(
|
||||
clippy::too_many_lines,
|
||||
reason = "Paragraph and column placement is one ordered state machine; splitting it would obscure the transitions between lines and columns."
|
||||
)]
|
||||
#[expect(
|
||||
clippy::cast_precision_loss,
|
||||
reason = "Column indices are at most MAX_COLUMNS and gap counts at most MAX_ATOMS, so every usize converted here is exact in f64."
|
||||
)]
|
||||
pub(super) fn layout(contents: &str, params: &MTextParams, base: &Fmt) -> MTextLayout {
|
||||
let height = base.height;
|
||||
let width = if params.width.is_finite() && params.width > 0.0 { params.width } else { 0.0 };
|
||||
let rotation = if params.rotation.is_finite() { params.rotation } else { 0.0 };
|
||||
let paragraphs = Paragraphs::scan(contents);
|
||||
let (atoms, fmts) = parse(contents, base.clone());
|
||||
let fmt = |i: usize| fmts.get(i).unwrap_or(base);
|
||||
let lines = LineBuilder::new(¶s, &fmts, base, width, h).build(&atoms);
|
||||
let fmt = |index: usize| fmts.get(index).unwrap_or(base);
|
||||
let lines = LineBuilder::new(¶graphs, &fmts, base, width, height).build(&atoms);
|
||||
|
||||
// Vertical placement: baselines below the top of each line's column.
|
||||
let ls = super::sane_line_spacing(p.line_spacing);
|
||||
let cols = p.columns.as_ref().filter(|_| width > 0.0);
|
||||
let line_spacing = super::sane_line_spacing(params.line_spacing);
|
||||
let cols = params.columns.as_ref().filter(|_| width > 0.0);
|
||||
let max_cols = match cols {
|
||||
Some(c) if c.dynamic => MAX_COLUMNS,
|
||||
Some(c) => c.count.clamp(1, MAX_COLUMNS),
|
||||
Some(spec) if spec.dynamic => MAX_COLUMNS,
|
||||
Some(spec) => spec.count.clamp(1, MAX_COLUMNS),
|
||||
None => 1,
|
||||
};
|
||||
let col_height = |c: usize| -> f64 {
|
||||
let col_height = |column: usize| -> f64 {
|
||||
let Some(spec) = cols else { return 0.0 };
|
||||
let v = if spec.heights.is_empty() { spec.height } else { spec.heights.get(c).or(spec.heights.last()).copied().unwrap_or(0.0) };
|
||||
if v.is_finite() && v > 0.0 { v } else { 0.0 }
|
||||
let value = if spec.heights.is_empty() { spec.height } else { spec.heights.get(column).or(spec.heights.last()).copied().unwrap_or(0.0) };
|
||||
if value.is_finite() && value > 0.0 { value } else { 0.0 }
|
||||
};
|
||||
let mut placed: Vec<(usize, f64)> = Vec::with_capacity(lines.len());
|
||||
let (mut c, mut y, mut first_in_col, mut force) = (0usize, 0.0f64, true, false);
|
||||
let (mut column, mut current_y, mut first_in_col, mut force) = (0usize, 0.0f64, true, false);
|
||||
let mut col_bottom = vec![0.0f64];
|
||||
let mut prev_para: Option<usize> = None;
|
||||
for l in &lines {
|
||||
let lh = if l.max_h > 0.0 { l.max_h } else { h };
|
||||
let new_para = prev_para != Some(l.para);
|
||||
let before = if new_para && prev_para.is_some() { paras.props(l.para).before * h } else { 0.0 };
|
||||
let step_h = if p.line_spacing_exact { h } else { lh };
|
||||
let pitch = |first: bool| if first { lh } else { step_h * 5.0 / 3.0 * ls + before };
|
||||
let hc = col_height(c);
|
||||
if !first_in_col && c + 1 < max_cols && (force || (hc > 0.0 && y + pitch(false) > hc + 1e-9)) {
|
||||
c += 1;
|
||||
for line in &lines {
|
||||
let line_height = if line.max_h > 0.0 { line.max_h } else { height };
|
||||
let new_para = prev_para != Some(line.para);
|
||||
let before = if new_para && prev_para.is_some() { paragraphs.props(line.para).before * height } else { 0.0 };
|
||||
let step_h = if params.line_spacing_exact { height } else { line_height };
|
||||
let pitch = |first: bool| if first { line_height } else { step_h * 5.0 / 3.0 * line_spacing + before };
|
||||
let column_height = col_height(column);
|
||||
if !first_in_col && column + 1 < max_cols && (force || (column_height > 0.0 && current_y + pitch(false) > column_height + 1e-9)) {
|
||||
column += 1;
|
||||
col_bottom.push(0.0);
|
||||
y = 0.0;
|
||||
current_y = 0.0;
|
||||
first_in_col = true;
|
||||
}
|
||||
force = false;
|
||||
y += pitch(first_in_col);
|
||||
current_y += pitch(first_in_col);
|
||||
first_in_col = false;
|
||||
placed.push((c, -y));
|
||||
if let Some(b) = col_bottom.get_mut(c) {
|
||||
*b = y;
|
||||
placed.push((column, -current_y));
|
||||
if let Some(bottom) = col_bottom.get_mut(column) {
|
||||
*bottom = current_y;
|
||||
}
|
||||
if l.para_end {
|
||||
y += paras.props(l.para).after * h;
|
||||
force = paras.column_break(l.para);
|
||||
if line.para_end {
|
||||
current_y += paragraphs.props(line.para).after * height;
|
||||
force = paragraphs.column_break(line.para);
|
||||
}
|
||||
prev_para = Some(l.para);
|
||||
prev_para = Some(line.para);
|
||||
}
|
||||
let n_cols = match cols {
|
||||
Some(spec) if !spec.dynamic => max_cols,
|
||||
_ => c + 1,
|
||||
_ => column + 1,
|
||||
};
|
||||
let content_h = col_bottom.iter().copied().fold(0.0, f64::max);
|
||||
let block_h = match cols {
|
||||
Some(_) => (0..n_cols).map(col_height).fold(content_h, f64::max),
|
||||
None => content_h,
|
||||
};
|
||||
let col_w = if width > 0.0 { width } else { lines.iter().map(|l| l.width + paras.props(l.para).right).fold(0.0, f64::max) };
|
||||
let gutter = cols.map(|s| s.gutter).filter(|g| g.is_finite() && *g >= 0.0).unwrap_or(0.0);
|
||||
let col_w = if width > 0.0 { width } else { lines.iter().map(|line| line.width + paragraphs.props(line.para).right).fold(0.0, f64::max) };
|
||||
let gutter = cols.map(|spec| spec.gutter).filter(|g| g.is_finite() && *g >= 0.0).unwrap_or(0.0);
|
||||
let total_w = col_w * n_cols as f64 + gutter * n_cols.saturating_sub(1) as f64;
|
||||
let attach = p.attach.clamp(1, 9) - 1;
|
||||
let attach = params.attach.clamp(1, 9) - 1;
|
||||
let (acol, arow) = (attach % 3, attach / 3);
|
||||
let top = match arow {
|
||||
0 => 0.0,
|
||||
@@ -673,41 +679,42 @@ pub(super) fn layout(contents: &str, p: &MTextParams, base: &Fmt) -> MTextLayout
|
||||
1 => -total_w / 2.0,
|
||||
_ => -total_w,
|
||||
};
|
||||
let reversed = cols.is_some_and(|s| s.reversed);
|
||||
let insert = p.insert;
|
||||
let xf = |q: Vec2| insert + q.rotate(rotation);
|
||||
let mut out = MTextLayout { lines: lines.iter().map(|l| l.text.clone()).collect(), ..Default::default() };
|
||||
let reversed = cols.is_some_and(|spec| spec.reversed);
|
||||
let insert = params.insert;
|
||||
let xf = |point: Vec2| insert + point.rotate(rotation);
|
||||
let mut out = MTextLayout { lines: lines.iter().map(|line| line.text.clone()).collect(), ..Default::default() };
|
||||
let mut allowance = super::Allowance::new();
|
||||
for (l, (c, base_y)) in lines.iter().zip(placed) {
|
||||
let pp = paras.props(l.para);
|
||||
let slot = if reversed { n_cols.saturating_sub(1).saturating_sub(c) } else { c };
|
||||
for (line, (column, base_y)) in lines.iter().zip(placed) {
|
||||
let pp = paragraphs.props(line.para);
|
||||
let slot = if reversed { n_cols.saturating_sub(1).saturating_sub(column) } else { column };
|
||||
let col_x = box_x0 + slot as f64 * (col_w + gutter);
|
||||
let right_edge = col_w - pp.right;
|
||||
let free = right_edge - l.width;
|
||||
let free = right_edge - line.width;
|
||||
let align = match pp.align {
|
||||
ParaAlign::Default => [ParaAlign::Left, ParaAlign::Center, ParaAlign::Right].get(usize::from(acol)).copied().unwrap_or_default(),
|
||||
a => a,
|
||||
alignment => alignment,
|
||||
};
|
||||
let spread = width > 0.0 && l.gaps > 0 && free > 0.0 && (align == ParaAlign::Distributed || (align == ParaAlign::Justify && !l.para_end));
|
||||
let spread =
|
||||
width > 0.0 && line.gaps > 0 && free > 0.0 && (align == ParaAlign::Distributed || (align == ParaAlign::Justify && !line.para_end));
|
||||
let (shift, per_gap) = match align {
|
||||
ParaAlign::Center => (free / 2.0, 0.0),
|
||||
ParaAlign::Right => (free, 0.0),
|
||||
_ if spread => (0.0, free / l.gaps as f64),
|
||||
_ if spread => (0.0, free / line.gaps as f64),
|
||||
_ => (0.0, 0.0),
|
||||
};
|
||||
for it in &l.items {
|
||||
let fm = fmt(it.fmt);
|
||||
for item in &line.items {
|
||||
let fm = fmt(item.fmt);
|
||||
if !allowance.left() {
|
||||
out.truncated = true;
|
||||
continue;
|
||||
}
|
||||
let mut sh = seg_shape(&it.seg, fm, it.x);
|
||||
let mut sh = seg_shape(&item.seg, fm, item.x);
|
||||
if !allowance.charge(&sh) {
|
||||
out.truncated = true;
|
||||
continue;
|
||||
}
|
||||
let off = Vec2::new(col_x + shift + per_gap * it.gap as f64, top + base_y);
|
||||
sh.map(|q| xf(q + off));
|
||||
let off = Vec2::new(col_x + shift + per_gap * item.gap as f64, top + base_y);
|
||||
sh.map(|point| xf(point + off));
|
||||
match out.pieces.last_mut() {
|
||||
Some(pc) if pc.color == fm.color => pc.shaped.extend(sh),
|
||||
_ => out.pieces.push(MTextPiece { color: fm.color, shaped: sh }),
|
||||
@@ -763,17 +770,17 @@ mod tests {
|
||||
#[test]
|
||||
fn props_parse_and_persist() {
|
||||
let p = Paragraphs::scan("\\pxi-3,l3,t3;1.\tone\\P2.\ttwo\\P\\pi0,l0,tz;plain");
|
||||
assert_eq!(p.props(0).first, -3.0);
|
||||
assert_eq!(p.props(0).left, 3.0);
|
||||
assert!((p.props(0).first + 3.0).abs() < f64::EPSILON);
|
||||
assert!((p.props(0).left - 3.0).abs() < f64::EPSILON);
|
||||
assert_eq!(p.props(0).tabs, vec![(3.0, TabKind::Left)]);
|
||||
assert_eq!(p.props(1), p.props(0));
|
||||
assert_eq!(p.props(2).left, 0.0);
|
||||
assert!(p.props(2).left.abs() < f64::EPSILON);
|
||||
assert!(p.props(2).tabs.is_empty());
|
||||
let mut pp = ParaProps::default();
|
||||
pp.apply("t2,c4,r6,d8,qc,b0.5");
|
||||
assert_eq!(pp.tabs, vec![(2.0, TabKind::Left), (4.0, TabKind::Center), (6.0, TabKind::Right), (8.0, TabKind::Decimal)]);
|
||||
assert_eq!(pp.align, ParaAlign::Center);
|
||||
assert_eq!(pp.before, 0.5);
|
||||
assert!((pp.before - 0.5).abs() < f64::EPSILON);
|
||||
let mut back = ParaProps::default();
|
||||
back.apply(pp.code().trim_start_matches("\\p").trim_end_matches(';'));
|
||||
assert_eq!(back, pp);
|
||||
|
||||
@@ -8,8 +8,10 @@
|
||||
pub(crate) const CAP: f64 = 6.0;
|
||||
pub(crate) const GAP: f64 = 1.6;
|
||||
|
||||
// List bullet: a small crossed diamond at mid x-height.
|
||||
#[expect(clippy::too_many_lines, reason = "The stroke font is one static glyph table; splitting it would obscure the character-to-outline mapping.")]
|
||||
pub(crate) fn glyph(c: char) -> Option<(f64, &'static str)> {
|
||||
let g: (f64, &str) = match c {
|
||||
Some(match c {
|
||||
' ' => (2.4, ""),
|
||||
'A' => (4.0, "0c2i4c 1f3f"),
|
||||
'B' => (4.0, "0c0i3i4h4g3f0f 3f4e4d3c0c"),
|
||||
@@ -25,7 +27,6 @@ pub(crate) fn glyph(c: char) -> Option<(f64, &'static str)> {
|
||||
'L' => (4.0, "0i0c4c"),
|
||||
'M' => (4.0, "0c0i2f4i4c"),
|
||||
'N' => (4.0, "0c0i4c4i"),
|
||||
'O' => (4.0, "1c0d0h1i3i4h4d3c1c"),
|
||||
'P' => (4.0, "0c0i3i4h4g3f0f"),
|
||||
'Q' => (4.0, "1c0d0h1i3i4h4d3c1c 2e4b"),
|
||||
'R' => (4.0, "0c0i3i4h4g3f0f 2f4c"),
|
||||
@@ -37,7 +38,7 @@ pub(crate) fn glyph(c: char) -> Option<(f64, &'static str)> {
|
||||
'X' => (4.0, "0i4c 0c4i"),
|
||||
'Y' => (4.0, "0i2f4i 2f2c"),
|
||||
'Z' => (4.0, "0i4i0c4c"),
|
||||
'0' => (4.0, "1c0d0h1i3i4h4d3c1c"),
|
||||
'O' | '0' => (4.0, "1c0d0h1i3i4h4d3c1c"),
|
||||
'1' => (4.0, "1h2i2c 1c3c"),
|
||||
'2' => (4.0, "0h1i3i4h4g0c4c"),
|
||||
'3' => (4.0, "0h1i3i4h4g3f2f 3f4e4d3c1c0d"),
|
||||
@@ -108,7 +109,6 @@ pub(crate) fn glyph(c: char) -> Option<(f64, &'static str)> {
|
||||
'°' => (2.0, "1i0h1g2h1i"),
|
||||
'±' => (4.0, "2e2i 0g4g 0d4d"),
|
||||
'Ø' | 'ø' | '⌀' => (4.0, "1c0d0h1i3i4h4d3c1c 0c4i"),
|
||||
// List bullet: a small crossed diamond at mid x-height.
|
||||
'•' => (2.0, "1d0e1f2e1d 0e2e 1d1f"),
|
||||
// Original Latin diacritics, composed from our own letter bodies and marks.
|
||||
'\u{00C0}' => (4.0, concat!("0c2i4c 1f3f", " 1k3j")),
|
||||
@@ -166,8 +166,7 @@ pub(crate) fn glyph(c: char) -> Option<(f64, &'static str)> {
|
||||
'\u{00FF}' => (4.0, concat!("0g2c 4g1a0a", " 1h1i 3h3i")),
|
||||
'\u{0178}' => (4.0, concat!("0i2f4i 2f2c", " 1j1k 3j3k")),
|
||||
_ => return None,
|
||||
};
|
||||
Some(g)
|
||||
})
|
||||
}
|
||||
|
||||
/// Decode one stroke string into point lists in font units.
|
||||
|
||||
@@ -23,8 +23,8 @@ pub enum Embedding {
|
||||
NotTrueType,
|
||||
}
|
||||
|
||||
fn table<'a>(f: &FontRef<'a>, t: &[u8; 4]) -> Option<&'a [u8]> {
|
||||
f.table_data(Tag::new(t)).map(|d| d.as_bytes())
|
||||
fn table<'a>(f: &FontRef<'a>, t: [u8; 4]) -> Option<&'a [u8]> {
|
||||
f.table_data(Tag::new(&t)).map(|d| d.as_bytes())
|
||||
}
|
||||
|
||||
fn u16_at(b: &[u8], i: usize) -> Option<u16> {
|
||||
@@ -34,10 +34,10 @@ fn u16_at(b: &[u8], i: usize) -> Option<u16> {
|
||||
/// The embedding permission of a face.
|
||||
pub fn embedding(face: &Face) -> Embedding {
|
||||
let Ok(f) = FontRef::from_index(&face.bytes, face.index) else { return Embedding::NotTrueType };
|
||||
if table(&f, b"glyf").is_none() || table(&f, b"loca").is_none() || table(&f, b"head").is_none() {
|
||||
if table(&f, *b"glyf").is_none() || table(&f, *b"loca").is_none() || table(&f, *b"head").is_none() {
|
||||
return Embedding::NotTrueType;
|
||||
}
|
||||
let Some(fs_type) = table(&f, b"OS/2").and_then(|o| u16_at(o, 8)) else { return Embedding::Allowed };
|
||||
let Some(fs_type) = table(&f, *b"OS/2").and_then(|o| u16_at(o, 8)) else { return Embedding::Allowed };
|
||||
if fs_type & 0x0200 != 0 {
|
||||
Embedding::BitmapOnly
|
||||
} else if fs_type & 0x000F == 0x0002 {
|
||||
|
||||
+38
-20
@@ -7,10 +7,10 @@
|
||||
//!
|
||||
//! System fonts are searched in the platform's own directories: `/System/Library/Fonts` and
|
||||
//! friends on macOS, `C:\Windows\Fonts` on Windows, `/system/fonts` and the product/vendor
|
||||
//! partitions on Android and HarmonyOS, and the XDG directories elsewhere. Web builds have no
|
||||
//! partitions on Android and `HarmonyOS`, and the XDG directories elsewhere. Web builds have no
|
||||
//! system fonts.
|
||||
//!
|
||||
//! Two process-wide settings (like AutoCAD's profile variables) control substitution:
|
||||
//! Two process-wide settings (like `AutoCAD`'s profile variables) control substitution:
|
||||
//! - [`font_alt`] (`FONTALT`): the font used for a text style font that can't be found (an SHX
|
||||
//! file we don't read, a missing TTF). Empty = the built-in stroke font.
|
||||
//! - [`fallback_fonts`] (`FONTFALLBACK`): fonts tried first for characters the text's font
|
||||
@@ -97,7 +97,7 @@ impl Face {
|
||||
pub(crate) fn glyph_ids(&self, chars: &[char]) -> Vec<Option<u32>> {
|
||||
let Some(f) = self.font() else { return vec![None; chars.len()] };
|
||||
let map = f.charmap();
|
||||
chars.iter().map(|c| map.map(*c).map(|g| g.to_u32())).collect()
|
||||
chars.iter().map(|c| map.map(*c).map(skrifa::GlyphId::to_u32)).collect()
|
||||
}
|
||||
fn names(&self) -> Vec<String> {
|
||||
let Some(f) = self.font() else { return Vec::new() };
|
||||
@@ -838,7 +838,13 @@ fn key(name: &str) -> String {
|
||||
|
||||
/// Names that mean a stroke font: never looked up as TrueType.
|
||||
fn is_stroke_name(k: &str) -> bool {
|
||||
k.is_empty() || k.ends_with(".shx") || k == crate::BUILTIN_FONT.to_ascii_lowercase() || k == "txt" || k == "simplex" || k == "romans"
|
||||
k.is_empty()
|
||||
|| k.ends_with(".shx")
|
||||
|| std::path::Path::new(k).extension().is_some_and(|extension| extension.eq_ignore_ascii_case("shx"))
|
||||
|| k == crate::BUILTIN_FONT.to_ascii_lowercase()
|
||||
|| k == "txt"
|
||||
|| k == "simplex"
|
||||
|| k == "romans"
|
||||
}
|
||||
|
||||
/// A face of an installed (or registered) font by file name or family name. Stroke-font names
|
||||
@@ -1025,26 +1031,31 @@ impl OutlinePen for Pen {
|
||||
self.push(Self::pt(x, y));
|
||||
}
|
||||
/// Flatten a quadratic segment into six samples, charging each retained point to the glyph budget.
|
||||
fn quad_to(&mut self, cx0: f32, cy0: f32, x: f32, y: f32) {
|
||||
let a = self.cur.last().copied().unwrap_or_default();
|
||||
let c = Self::pt(cx0, cy0);
|
||||
let b = Self::pt(x, y);
|
||||
for i in 1..=6 {
|
||||
let t = f64::from(i) / 6.0;
|
||||
let u = 1.0 - t;
|
||||
self.push(a * (u * u) + c * (2.0 * u * t) + b * (t * t));
|
||||
fn quad_to(&mut self, cx0: f32, cy0: f32, end_x: f32, end_y: f32) {
|
||||
let start = self.cur.last().copied().unwrap_or_default();
|
||||
let control = Self::pt(cx0, cy0);
|
||||
let end = Self::pt(end_x, end_y);
|
||||
for step in 1..=6 {
|
||||
let ratio = f64::from(step) / 6.0;
|
||||
let inverse_ratio = 1.0 - ratio;
|
||||
self.push(start * (inverse_ratio * inverse_ratio) + control * (2.0 * inverse_ratio * ratio) + end * (ratio * ratio));
|
||||
}
|
||||
}
|
||||
/// Flatten a cubic segment into eight samples, charging each retained point to the glyph budget.
|
||||
fn curve_to(&mut self, cx0: f32, cy0: f32, cx1: f32, cy1: f32, x: f32, y: f32) {
|
||||
let a = self.cur.last().copied().unwrap_or_default();
|
||||
fn curve_to(&mut self, cx0: f32, cy0: f32, cx1: f32, cy1: f32, end_x: f32, end_y: f32) {
|
||||
let start = self.cur.last().copied().unwrap_or_default();
|
||||
let c0 = Self::pt(cx0, cy0);
|
||||
let c1 = Self::pt(cx1, cy1);
|
||||
let b = Self::pt(x, y);
|
||||
for i in 1..=8 {
|
||||
let t = f64::from(i) / 8.0;
|
||||
let u = 1.0 - t;
|
||||
self.push(a * (u * u * u) + c0 * (3.0 * u * u * t) + c1 * (3.0 * u * t * t) + b * (t * t * t));
|
||||
let end = Self::pt(end_x, end_y);
|
||||
for step in 1..=8 {
|
||||
let ratio = f64::from(step) / 8.0;
|
||||
let inverse_ratio = 1.0 - ratio;
|
||||
self.push(
|
||||
start * (inverse_ratio * inverse_ratio * inverse_ratio)
|
||||
+ c0 * (3.0 * inverse_ratio * inverse_ratio * ratio)
|
||||
+ c1 * (3.0 * inverse_ratio * ratio * ratio)
|
||||
+ end * (ratio * ratio * ratio),
|
||||
);
|
||||
}
|
||||
}
|
||||
fn close(&mut self) {
|
||||
@@ -1054,7 +1065,7 @@ impl OutlinePen for Pen {
|
||||
|
||||
/// How far below the baseline a face reaches, as a fraction of the text height (which is the
|
||||
/// face's cap height): its descent over its cap height. A bottom-justified text's alignment
|
||||
/// point is there, as AutoCAD places it (#2229). `None` when the face has no usable descent.
|
||||
/// point is there, as `AutoCAD` places it (#2229). `None` when the face has no usable descent.
|
||||
pub fn descent_ratio(face: &Face) -> Option<f64> {
|
||||
let f = face.font()?;
|
||||
let descent = -f64::from(f.metrics(Size::new(UPEM), LocationRef::default()).descent);
|
||||
@@ -1388,6 +1399,13 @@ mod family_tests {
|
||||
let many: Vec<String> = (0..100).map(|i| format!("gost{i:03}")).collect();
|
||||
assert!(family_candidates(&many, "gosttypea", "gost").len() <= MAX_FAMILY_FILES + MAX_FIRST_WORD_FILES);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dotfile_shx_names_are_stroke_names() {
|
||||
for name in [".shx", ".shx.ttf", ".SHX", ".SHX.TTF", "sub/.shx", "sub/.SHX"] {
|
||||
assert!(is_stroke_name(&key(name)), "{name}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
||||
@@ -22,7 +22,7 @@ fn max_x(l: &MTextLayout) -> f64 {
|
||||
|
||||
/// Leftmost x of the geometry of line `n` (0 = first; baselines 5/3 apart below -1).
|
||||
fn line_min_x(l: &MTextLayout, n: usize) -> f64 {
|
||||
let base = -1.0 - n as f64 * 5.0 / 3.0;
|
||||
let base = -1.0 - f64::from(u32::try_from(n).unwrap_or(u32::MAX)) * 5.0 / 3.0;
|
||||
l.strokes.iter().flatten().filter(|p| p.y >= base - 0.4 && p.y <= base + 1.3).map(|p| p.x).fold(f64::MAX, f64::min)
|
||||
}
|
||||
|
||||
@@ -59,7 +59,7 @@ fn paragraph_alignment_overrides_the_attachment() {
|
||||
let right = lay("\\pqr;ab", 10.0, None);
|
||||
assert!(max_x(&right) > 9.0 && max_x(&right) <= 10.0 + 1e-9, "{}", max_x(&right));
|
||||
let centre = lay("\\pqc;ab", 10.0, None);
|
||||
let c = (min_x(¢re) + max_x(¢re)) / 2.0;
|
||||
let c = f64::midpoint(min_x(¢re), max_x(¢re));
|
||||
assert!((c - 5.0).abs() < 0.5, "{c}");
|
||||
}
|
||||
|
||||
@@ -79,7 +79,7 @@ fn text_flows_through_static_columns() {
|
||||
assert!((l.bounds.width() - 34.0).abs() < 1e-9);
|
||||
assert!((l.bounds.height() - 6.0).abs() < 1e-9);
|
||||
for col in 0..3 {
|
||||
let x0 = col as f64 * 12.0;
|
||||
let x0 = f64::from(col) * 12.0;
|
||||
assert!(xs(&l).iter().any(|x| *x >= x0 && *x <= x0 + 10.0), "column {col} has text");
|
||||
}
|
||||
// The gutters stay empty.
|
||||
|
||||
@@ -65,7 +65,7 @@ impl Bounds2 {
|
||||
// (max - min) can overflow even when both endpoints and their midpoint
|
||||
// are finite. Halve first when the endpoints have opposite signs.
|
||||
let mid = |a: f64, b: f64| {
|
||||
if a.is_sign_negative() != b.is_sign_negative() { a * 0.5 + b * 0.5 } else { a + (b - a) * 0.5 }
|
||||
if a.is_sign_negative() == b.is_sign_negative() { a + (b - a) * 0.5 } else { a * 0.5 + b * 0.5 }
|
||||
};
|
||||
Vec2::new(mid(self.min.x, self.max.x), mid(self.min.y, self.max.y))
|
||||
}
|
||||
@@ -101,17 +101,17 @@ mod tests {
|
||||
let b = Bounds2::new(Vec2::new(1e308, 0.0), Vec2::new(1.6e308, 10.0));
|
||||
assert!(b.center().x.is_finite());
|
||||
assert!((b.center().x / 1e308 - 1.3).abs() < 1e-12);
|
||||
assert_eq!(b.center().y, 5.0);
|
||||
assert_eq!(b.center().y.to_bits(), 5.0_f64.to_bits());
|
||||
assert_eq!(Bounds2::EMPTY.center(), Vec2::ZERO);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn width_and_height_stay_finite_for_opposite_large_coordinates() {
|
||||
let b = Bounds2::new(Vec2::new(-1e308, -1e308), Vec2::new(1e308, 1e308));
|
||||
assert_eq!(b.width(), f64::MAX);
|
||||
assert_eq!(b.height(), f64::MAX);
|
||||
assert_eq!(b.width().to_bits(), f64::MAX.to_bits());
|
||||
assert_eq!(b.height().to_bits(), f64::MAX.to_bits());
|
||||
let b = Bounds2::new(Vec2::new(1e308, 0.0), Vec2::new(1.6e308, 10.0));
|
||||
assert!((b.width() / 1e308 - 0.6).abs() < 1e-12);
|
||||
assert_eq!(b.height(), 10.0);
|
||||
assert_eq!(b.height().to_bits(), 10.0_f64.to_bits());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -113,13 +113,14 @@ impl Arc {
|
||||
pub fn bounds(&self) -> Bounds2 {
|
||||
let mut b = Bounds2::from_points([self.start_point(), self.end_point()]);
|
||||
for k in 0..4 {
|
||||
let a = k as f64 * PI / 2.0;
|
||||
let a = f64::from(k) * PI / 2.0;
|
||||
if self.contains_angle(a) {
|
||||
b.add(Vec2::polar(self.center, self.radius, a));
|
||||
}
|
||||
}
|
||||
b
|
||||
}
|
||||
#[expect(clippy::cast_precision_loss, reason = "arc_segments caps the sample count at 4096, so every sample index is exact as f64.")]
|
||||
pub fn tessellate(&self, tol: f64, out: &mut Vec<Vec2>) {
|
||||
let sweep = self.sweep();
|
||||
let n = arc_segments(self.radius, sweep, tol);
|
||||
@@ -192,6 +193,7 @@ impl Circle {
|
||||
/// up to two outer (belt) tangents and two inner (crossed) tangents. Empty for concentric
|
||||
/// circles or when one circle lies inside the other; tangents that touch both circles at the
|
||||
/// same point (circles touching each other) are left out.
|
||||
#[expect(clippy::many_single_char_names, reason = "Circle-tangent equations use conventional r/v/d/u/c/h/n/p/q notation.")]
|
||||
pub fn common_tangents(&self, other: &Circle) -> Vec<(Vec2, Vec2)> {
|
||||
let (r1, r2) = (self.radius, other.radius);
|
||||
let v = other.center - self.center;
|
||||
@@ -264,6 +266,7 @@ impl Ellipse {
|
||||
let (start, end) = if u.cross(v) >= 0.0 { (self.start - t0, self.end - t0) } else { (t0 - self.end, t0 - self.start) };
|
||||
Ellipse { center, major: u, ratio, start: norm_angle(start), end: norm_angle(end) }
|
||||
}
|
||||
#[expect(clippy::cast_precision_loss, reason = "arc_segments caps the sample count at 4096, so every sample index is exact as f64.")]
|
||||
pub fn tessellate(&self, tol: f64, out: &mut Vec<Vec2>) {
|
||||
let r = self.major.len();
|
||||
let sweep = self.sweep();
|
||||
@@ -381,7 +384,7 @@ impl Segment {
|
||||
let start = out.len();
|
||||
arc.tessellate(tol, out);
|
||||
if !ccw && let Some(s) = out.get_mut(start..) {
|
||||
s.reverse()
|
||||
s.reverse();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -590,6 +593,7 @@ impl Polyline {
|
||||
}
|
||||
/// Area centroid of the closed polyline, exact with bulges: the chord triangles fanned from the
|
||||
/// first vertex plus each bulge's circular segment, weighted by signed area. `None` at zero area.
|
||||
#[expect(clippy::many_single_char_names, reason = "Centroid integration uses conventional a/b/c/d/t area and point notation.")]
|
||||
pub fn centroid(&self) -> Option<Vec2> {
|
||||
let origin = self.vertices.first()?.p;
|
||||
let n = self.vertices.len();
|
||||
|
||||
@@ -69,6 +69,7 @@ impl TanCurve {
|
||||
}
|
||||
|
||||
/// The point at distance `d` along the left normal at `t` (`None` where the curve stops).
|
||||
#[expect(clippy::many_single_char_names, reason = "The offset equation uses conventional t/d/p/n/q geometric notation.")]
|
||||
fn offset(&self, t: f64, d: f64) -> Option<Vec2> {
|
||||
let p = self.point(t);
|
||||
if d == 0.0 {
|
||||
@@ -125,6 +126,11 @@ impl TanCurve {
|
||||
}
|
||||
|
||||
/// A sampled offset curve: runs of consecutive (parameter, point) samples.
|
||||
#[expect(
|
||||
clippy::cast_precision_loss,
|
||||
clippy::many_single_char_names,
|
||||
reason = "Sample counts are capped by MAX_SPLINE_SAMPLES, and c/r/d/i/t/p name the curve, range, offset and sample equations."
|
||||
)]
|
||||
fn sample(c: &TanCurve, r: &Range, d: f64) -> Vec<Vec<(f64, Vec2)>> {
|
||||
let n = c.sample_count();
|
||||
let mut runs: Vec<Vec<(f64, Vec2)>> = vec![Vec::new()];
|
||||
|
||||
@@ -14,6 +14,7 @@ pub fn line_line_infinite(a1: Vec2, a2: Vec2, b1: Vec2, b2: Vec2) -> Option<(Vec
|
||||
}
|
||||
|
||||
/// Intersection of two finite segments.
|
||||
#[expect(clippy::many_single_char_names, reason = "Segment endpoints and parameters use conventional a/b/p/t/u geometric notation.")]
|
||||
pub fn line_line(a: &Line, b: &Line) -> Option<Vec2> {
|
||||
let (p, t, u) = line_line_infinite(a.a, a.b, b.a, b.b)?;
|
||||
let tol = 1e-9;
|
||||
@@ -21,6 +22,7 @@ pub fn line_line(a: &Line, b: &Line) -> Option<Vec2> {
|
||||
}
|
||||
|
||||
/// Intersections of the infinite line through `l` with a circle. Returns points with line params.
|
||||
#[expect(clippy::many_single_char_names, reason = "The line/circle quadratic uses conventional a/d/f/t mathematical notation.")]
|
||||
pub fn line_circle(l: &Line, c: &Circle) -> Vec<(Vec2, f64)> {
|
||||
let d = l.b - l.a;
|
||||
let f = l.a - c.center;
|
||||
|
||||
@@ -65,6 +65,11 @@ pub fn rad(d: f64) -> f64 {
|
||||
}
|
||||
|
||||
/// Number of segments needed to approximate an arc of `radius` and `sweep` within `tol`.
|
||||
#[expect(
|
||||
clippy::cast_possible_truncation,
|
||||
clippy::cast_sign_loss,
|
||||
reason = "The segment count is nonnegative and immediately clamped to 1..=4096; float-to-usize saturation handles out-of-range values."
|
||||
)]
|
||||
pub fn arc_segments(radius: f64, sweep: f64, tol: f64) -> usize {
|
||||
let r = radius.abs();
|
||||
if !(r.is_finite() && sweep.is_finite()) || r <= EPS {
|
||||
|
||||
@@ -73,6 +73,7 @@ impl Mat3 {
|
||||
pub fn det(&self) -> f64 {
|
||||
self.a * self.d - self.b * self.c
|
||||
}
|
||||
#[expect(clippy::many_single_char_names, reason = "Matrix coefficients use the same a–f notation as Mat3 and the affine-transform formula.")]
|
||||
pub fn inverse(&self) -> Option<Mat3> {
|
||||
let det = self.det();
|
||||
if det.abs() < 1e-300 || !det.is_finite() {
|
||||
|
||||
+50
-18
@@ -44,8 +44,9 @@ const GAUSS: [(f64, f64); 5] = [
|
||||
(0.906_179_845_938_664, 0.236_926_885_056_189_1),
|
||||
];
|
||||
|
||||
#[expect(clippy::many_single_char_names, reason = "Gauss–Legendre quadrature uses conventional a/b/f/m/h/x/w notation.")]
|
||||
fn gauss(a: f64, b: f64, f: impl Fn(f64) -> f64) -> f64 {
|
||||
let (m, h) = ((a + b) / 2.0, (b - a) / 2.0);
|
||||
let (m, h) = (f64::midpoint(a, b), (b - a) / 2.0);
|
||||
GAUSS.iter().map(|(x, w)| w * f(m + h * x)).sum::<f64>() * h
|
||||
}
|
||||
|
||||
@@ -55,8 +56,12 @@ const MAX_GAUSS_DEPTH: usize = 10;
|
||||
|
||||
/// `gauss` over [a, b], halving until the two halves agree with the whole: a fixed panel count
|
||||
/// is far off on a tight bend, and the arc-length inverse must agree with the measure.
|
||||
#[expect(
|
||||
clippy::many_single_char_names,
|
||||
reason = "Adaptive quadrature keeps the panel endpoints, midpoint and left/right integrals in mathematical notation."
|
||||
)]
|
||||
fn adaptive_gauss(a: f64, b: f64, whole: f64, f: &impl Fn(f64) -> f64, depth: usize) -> f64 {
|
||||
let m = (a + b) / 2.0;
|
||||
let m = f64::midpoint(a, b);
|
||||
let (l, r) = (gauss(a, m, f), gauss(m, b, f));
|
||||
if depth == 0 || !(l + r).is_finite() || (l + r - whole).abs() <= 1e-10 * (l + r).abs() {
|
||||
return l + r;
|
||||
@@ -76,6 +81,7 @@ fn bezier_knots(breaks: &[f64], p: usize) -> Vec<f64> {
|
||||
}
|
||||
|
||||
/// One degree elevation of a homogeneous Bézier piece.
|
||||
#[expect(clippy::cast_precision_loss, reason = "Bézier pieces are bounded by MAX_EDIT_DEGREE, so their control indices are exact as f64.")]
|
||||
fn elevate_bezier(p: &[H]) -> Vec<H> {
|
||||
let n = p.len();
|
||||
let zero = (Vec2::ZERO, 0.0);
|
||||
@@ -166,6 +172,11 @@ impl Spline {
|
||||
}
|
||||
|
||||
/// [`Spline::derivative_unchecked`] before a value past f64's range is read as zero.
|
||||
#[expect(
|
||||
clippy::cast_precision_loss,
|
||||
clippy::many_single_char_names,
|
||||
reason = "The NURBS derivative keeps its standard equation notation, and MAX_DEGREE makes p exact as f64."
|
||||
)]
|
||||
fn velocity(&self, t: f64) -> Vec2 {
|
||||
let p = self.degree;
|
||||
let Some(n) = self.control.len().checked_sub(1) else { return Vec2::ZERO };
|
||||
@@ -220,6 +231,7 @@ impl Spline {
|
||||
|
||||
/// Insert knot `t` once (Boehm's algorithm, in homogeneous coordinates). The result has no
|
||||
/// fit data and is open.
|
||||
#[expect(clippy::many_single_char_names, reason = "Boehm knot insertion keeps the standard p/n/k/i/h/a equation notation.")]
|
||||
pub fn insert_knot(&self, t: f64) -> Option<Spline> {
|
||||
if !self.is_valid() || !t.is_finite() || self.control.len() >= MAX_EDIT_CONTROL {
|
||||
return None;
|
||||
@@ -321,7 +333,7 @@ impl Spline {
|
||||
let (lo, hi) = self.domain();
|
||||
let mut s = self.clone();
|
||||
s.fit.clear();
|
||||
s.fit_opts = Default::default();
|
||||
s.fit_opts = crate::FitOptions::default();
|
||||
if !s.knots.get(..=p).is_some_and(|k| k.iter().all(|x| (*x - lo).abs() < 1e-12)) {
|
||||
s = s.split_raw(lo)?.1;
|
||||
}
|
||||
@@ -412,6 +424,10 @@ impl Spline {
|
||||
/// point becomes their midpoint). Degrees are matched by elevation, weights rescaled so the
|
||||
/// junction carries one weight, and `other`'s parameters follow on at a similar speed. The
|
||||
/// junction is a knot of multiplicity `degree`, so the curve passes through it exactly.
|
||||
#[expect(
|
||||
clippy::many_single_char_names,
|
||||
reason = "Spline joining keeps the two curves, homogeneous points and knot spans in standard short notation."
|
||||
)]
|
||||
pub fn joined(&self, other: &Spline) -> Option<Spline> {
|
||||
let deg = self.degree.max(other.degree);
|
||||
let a = self.elevated(deg)?;
|
||||
@@ -440,6 +456,7 @@ impl Spline {
|
||||
|
||||
/// A straight line from `a` to `b` as a clamped spline of `degree` (evenly spaced control
|
||||
/// points, parameter = distance).
|
||||
#[expect(clippy::cast_precision_loss, reason = "The degree is clamped by MAX_EDIT_DEGREE (25), so every control index is exact as f64.")]
|
||||
pub fn from_line(a: Vec2, b: Vec2, degree: usize) -> Spline {
|
||||
let p = degree.clamp(1, MAX_EDIT_DEGREE);
|
||||
let control = (0..=p).map(|i| a.lerp(b, i as f64 / p as f64)).collect();
|
||||
@@ -453,6 +470,13 @@ impl Spline {
|
||||
/// The elliptical arc `center + u·cos θ + v·sin θ` for θ from `start` over `sweep` (negative
|
||||
/// runs clockwise) as an exact rational quadratic spline, in pieces of at most a quarter
|
||||
/// turn. Circular arcs are the case `|u| = |v|`, `u ⟂ v`.
|
||||
#[expect(
|
||||
clippy::cast_precision_loss,
|
||||
clippy::cast_possible_truncation,
|
||||
clippy::cast_sign_loss,
|
||||
clippy::many_single_char_names,
|
||||
reason = "Conic decomposition uses one to four pieces and standard parametric notation, so all piece indices are exact as f64."
|
||||
)]
|
||||
pub fn from_conic_arc(center: Vec2, u: Vec2, v: Vec2, start: f64, sweep: f64) -> Option<Spline> {
|
||||
if !(start.is_finite() && sweep.is_finite() && center.is_finite() && u.is_finite() && v.is_finite())
|
||||
|| sweep.abs() < 1e-12
|
||||
@@ -515,7 +539,7 @@ impl Spline {
|
||||
for w in cuts.windows(2) {
|
||||
let (Some(&x0), Some(&x1)) = (w.first(), w.get(1)) else { continue };
|
||||
for i in 0..4 {
|
||||
out.push((x0 + (x1 - x0) * i as f64 / 4.0, x0 + (x1 - x0) * (i + 1) as f64 / 4.0));
|
||||
out.push((x0 + (x1 - x0) * f64::from(i) / 4.0, x0 + (x1 - x0) * f64::from(i + 1) / 4.0));
|
||||
}
|
||||
}
|
||||
out
|
||||
@@ -587,7 +611,7 @@ impl Spline {
|
||||
let (near, far) = if len > 0.0 { (x0, x1) } else { (x1, x0) };
|
||||
let (mut s0, mut s1) = (near, far);
|
||||
for _ in 0..60 {
|
||||
let m = (s0 + s1) / 2.0;
|
||||
let m = f64::midpoint(s0, s1);
|
||||
let lm = self.panel_length(near.min(m), near.max(m), Spline::derivative_unchecked);
|
||||
if lm < rest {
|
||||
s0 = m;
|
||||
@@ -595,7 +619,7 @@ impl Spline {
|
||||
s1 = m;
|
||||
}
|
||||
}
|
||||
return (s0 + s1) / 2.0;
|
||||
return f64::midpoint(s0, s1);
|
||||
}
|
||||
acc += l;
|
||||
}
|
||||
@@ -610,6 +634,12 @@ impl Ellipse {
|
||||
}
|
||||
|
||||
/// Arc length from parameter `t0` counter-clockwise over `sweep` (radians, >= 0).
|
||||
#[expect(
|
||||
clippy::cast_precision_loss,
|
||||
clippy::cast_possible_truncation,
|
||||
clippy::cast_sign_loss,
|
||||
reason = "The quadrature panel count is clamped to 1..=512, so panel indices are nonnegative and exact as f64."
|
||||
)]
|
||||
pub fn arc_length_from(&self, t0: f64, sweep: f64) -> f64 {
|
||||
if !(t0.is_finite() && sweep.is_finite()) || sweep <= 0.0 {
|
||||
return 0.0;
|
||||
@@ -643,14 +673,14 @@ impl Ellipse {
|
||||
let along = |s: f64| if len >= 0.0 { self.arc_length_from(t0, s) } else { self.arc_length_from(t0 - s, s) };
|
||||
let (mut a, mut b) = (0.0, TAU);
|
||||
for _ in 0..80 {
|
||||
let m = (a + b) / 2.0;
|
||||
let m = f64::midpoint(a, b);
|
||||
if along(m) < target {
|
||||
a = m;
|
||||
} else {
|
||||
b = m;
|
||||
}
|
||||
}
|
||||
let s = (a + b) / 2.0;
|
||||
let s = f64::midpoint(a, b);
|
||||
Some(if len >= 0.0 { t0 + s } else { t0 - s })
|
||||
}
|
||||
}
|
||||
@@ -795,7 +825,7 @@ mod tests {
|
||||
s.weights = vec![1.0, 2.0, 0.5, 1.0, 1.5];
|
||||
let (lo, hi) = s.domain();
|
||||
for i in 1..20 {
|
||||
let t = lo + (hi - lo) * i as f64 / 20.0;
|
||||
let t = lo + (hi - lo) * f64::from(i) / 20.0;
|
||||
let h = 1e-6;
|
||||
let fd = (s.eval(t + h) - s.eval(t - h)) / (2.0 * h);
|
||||
assert!(s.derivative(t).near(fd, 1e-4), "{t}: {:?} vs {fd:?}", s.derivative(t));
|
||||
@@ -825,7 +855,7 @@ mod tests {
|
||||
assert!(!c.is_periodic());
|
||||
let ((plo, phi), (clo, chi)) = (p.domain(), c.domain());
|
||||
for i in 0..=20 {
|
||||
let f = i as f64 / 20.0;
|
||||
let f = f64::from(i) / 20.0;
|
||||
assert!(p.eval(plo + (phi - plo) * f).near(c.eval(clo + (chi - clo) * f), 1e-9));
|
||||
}
|
||||
assert!(c.control.first().unwrap().near(p.eval(plo), 1e-9));
|
||||
@@ -837,7 +867,7 @@ mod tests {
|
||||
let e = s.elevated(5).unwrap();
|
||||
assert_eq!(e.degree, 5);
|
||||
for i in 0..=20 {
|
||||
let t = i as f64 / 20.0;
|
||||
let t = f64::from(i) / 20.0;
|
||||
assert!(e.eval(t).near(s.eval(t), 1e-9), "{t}");
|
||||
}
|
||||
// A rational quarter circle elevated to a cubic stays on the circle.
|
||||
@@ -845,12 +875,13 @@ mod tests {
|
||||
let q3 = q.elevated(3).unwrap();
|
||||
let (lo, hi) = q3.domain();
|
||||
for i in 0..=20 {
|
||||
assert!((q3.eval(lo + (hi - lo) * i as f64 / 20.0).len() - 2.0).abs() < 1e-9);
|
||||
assert!((q3.eval(lo + (hi - lo) * f64::from(i) / 20.0).len() - 2.0).abs() < 1e-9);
|
||||
}
|
||||
assert!(s.elevated(2).is_none() && s.elevated(1000).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[expect(clippy::many_single_char_names, reason = "The ellipse equation check keeps conventional center/axis/point notation.")]
|
||||
fn conic_arcs_are_exact() {
|
||||
let e = Ellipse { center: Vec2::new(1.0, 2.0), major: Vec2::new(4.0, 3.0), ratio: 0.5, start: 0.3, end: 5.5 };
|
||||
let s = Spline::from_ellipse(&e).unwrap();
|
||||
@@ -860,7 +891,7 @@ mod tests {
|
||||
let (a, b) = (e.major.len(), e.major.len() * e.ratio);
|
||||
let ux = e.major.normalized();
|
||||
for i in 0..=40 {
|
||||
let p = s.eval(lo + (hi - lo) * i as f64 / 40.0) - e.center;
|
||||
let p = s.eval(lo + (hi - lo) * f64::from(i) / 40.0) - e.center;
|
||||
let (x, y) = (p.dot(ux), p.dot(ux.perp()));
|
||||
assert!(((x / a).powi(2) + (y / b).powi(2) - 1.0).abs() < 1e-9);
|
||||
}
|
||||
@@ -881,8 +912,8 @@ mod tests {
|
||||
assert!(j.eval(lo).near(Vec2::new(-5.0, 0.0), 1e-12) && j.eval(hi).near(Vec2::new(12.0, 2.0), 1e-12));
|
||||
// The line part is straight (parameter = distance), the spline part unchanged.
|
||||
for i in 0..=10 {
|
||||
assert!(j.eval(lo + 0.5 * i as f64).near(Vec2::new(-5.0 + 0.5 * i as f64, 0.0), 1e-12));
|
||||
let f = i as f64 / 10.0;
|
||||
assert!(j.eval(lo + 0.5 * f64::from(i)).near(Vec2::new(-5.0 + 0.5 * f64::from(i), 0.0), 1e-12));
|
||||
let f = f64::from(i) / 10.0;
|
||||
assert!(j.eval(5.0 + (hi - 5.0) * f).near(s.eval(f), 1e-9));
|
||||
}
|
||||
assert!((j.length() - (5.0 + s.length())).abs() < 1e-6);
|
||||
@@ -917,7 +948,7 @@ mod tests {
|
||||
assert!(q.eval(t).near(Vec2::new(0.0, 2.0), 1e-6));
|
||||
let t = q.param_at_length(hi, -std::f64::consts::PI / 2.0);
|
||||
assert!(q.eval(t).near(Vec2::new(-2f64.sqrt(), 2f64.sqrt()), 1e-6));
|
||||
assert_eq!(q.param_at_length(lo, 1e9), hi);
|
||||
assert_eq!(q.param_at_length(lo, 1e9).to_bits(), hi.to_bits());
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -966,12 +997,13 @@ mod tests {
|
||||
nan.knots[nan.degree] = f64::NAN;
|
||||
assert!(!nan.is_valid() && nan.domain().0.is_nan());
|
||||
for s in [reversed, nan] {
|
||||
assert_eq!(s.param_at_length(0.5, 1.0), 0.5);
|
||||
assert_eq!(s.param_at_length(0.5, -1.0), 0.5);
|
||||
assert_eq!(s.param_at_length(0.5, 1.0).to_bits(), 0.5_f64.to_bits());
|
||||
assert_eq!(s.param_at_length(0.5, -1.0).to_bits(), 0.5_f64.to_bits());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[expect(clippy::many_single_char_names, reason = "The ellipse arc-length reference uses conventional a/b/h/t notation.")]
|
||||
fn ellipse_arc_length() {
|
||||
let c = Ellipse::full(Vec2::ZERO, Vec2::new(3.0, 0.0), 1.0);
|
||||
assert!((c.length() - TAU * 3.0).abs() < 1e-9);
|
||||
|
||||
@@ -22,13 +22,15 @@ impl Rng {
|
||||
x ^= x << 25;
|
||||
x ^= x >> 27;
|
||||
self.0 = x;
|
||||
x.wrapping_mul(0x2545F4914F6CDD1D)
|
||||
x.wrapping_mul(0x2545_F491_4F6C_DD1D)
|
||||
}
|
||||
/// Uniform in `[-scale, scale]`.
|
||||
#[expect(clippy::cast_precision_loss, reason = "The generator keeps exactly 53 random bits, and 2^53 is exactly representable as f64.")]
|
||||
fn f64(&mut self, scale: f64) -> f64 {
|
||||
((self.next() >> 11) as f64 / (1u64 << 53) as f64) * 2.0 * scale - scale
|
||||
}
|
||||
/// Uniform in `[lo, hi]`.
|
||||
#[expect(clippy::cast_precision_loss, reason = "The generator keeps exactly 53 random bits, and 2^53 is exactly representable as f64.")]
|
||||
fn range(&mut self, lo: f64, hi: f64) -> f64 {
|
||||
lo + (hi - lo) * (self.next() >> 11) as f64 / (1u64 << 53) as f64
|
||||
}
|
||||
@@ -96,7 +98,7 @@ fn on_line(p: Vec2, a: Vec2, d: Vec2, rel: f64) -> bool {
|
||||
/// The infinite-line intersection lies on both lines, and swapping the lines gives the same point.
|
||||
#[test]
|
||||
fn line_line_infinite_lies_on_both_and_is_symmetric() {
|
||||
let mut r = Rng::new(0xC0FFEE);
|
||||
let mut r = Rng::new(0xC0_FFEE);
|
||||
let mut checked = 0;
|
||||
for _ in 0..4000 {
|
||||
let (a1, a2, b1, b2) = (r.vec(1000.0), r.vec(1000.0), r.vec(1000.0), r.vec(1000.0));
|
||||
@@ -115,8 +117,9 @@ fn line_line_infinite_lies_on_both_and_is_symmetric() {
|
||||
|
||||
/// The finite-line result agrees with the parameters of the infinite one.
|
||||
#[test]
|
||||
#[expect(clippy::many_single_char_names, reason = "The property uses the same a/b/p/t/u notation as the geometric equations under test.")]
|
||||
fn line_line_matches_infinite_parameters() {
|
||||
let mut r = Rng::new(0xBAD5EED);
|
||||
let mut r = Rng::new(0xBAD_5EED);
|
||||
for _ in 0..4000 {
|
||||
let a = Line::new(r.vec(100.0), r.vec(100.0));
|
||||
let b = Line::new(r.vec(100.0), r.vec(100.0));
|
||||
@@ -220,7 +223,7 @@ fn circle_circle_hits_lie_on_both_and_match_the_closed_form() {
|
||||
/// Degenerate and hostile circles: concentric, contained, negative/NaN radii, extreme centres.
|
||||
#[test]
|
||||
fn circle_circle_degenerate_and_hostile_never_panic() {
|
||||
let mut r = Rng::new(0xD15EA5E);
|
||||
let mut r = Rng::new(0xD15_EA5E);
|
||||
for _ in 0..3000 {
|
||||
let c1 = Circle { center: Vec2::new(r.hostile(), r.hostile()), radius: r.hostile() };
|
||||
let c2 = Circle { center: Vec2::new(r.hostile(), r.hostile()), radius: r.hostile() };
|
||||
@@ -240,7 +243,7 @@ fn circle_circle_degenerate_and_hostile_never_panic() {
|
||||
/// Extending segments only adds hits: the finite result is a subset of the extended one.
|
||||
#[test]
|
||||
fn segment_extension_only_adds_hits() {
|
||||
let mut r = Rng::new(0x5E6C0DE);
|
||||
let mut r = Rng::new(0x5E6_C0DE);
|
||||
for _ in 0..3000 {
|
||||
let s1 = Segment::Line(Line::new(r.vec(100.0), r.vec(100.0)));
|
||||
let s2 = Segment::Line(Line::new(r.vec(100.0), r.vec(100.0)));
|
||||
@@ -259,6 +262,7 @@ fn segment_extension_only_adds_hits() {
|
||||
|
||||
/// The closest point on a line is a fixed point of `closest`, and the offset is perpendicular.
|
||||
#[test]
|
||||
#[expect(clippy::many_single_char_names, reason = "The property uses conventional line/point/parameter notation from the closest-point equations.")]
|
||||
fn line_closest_is_a_fixed_point_and_perpendicular() {
|
||||
let mut r = Rng::new(0xC105E);
|
||||
for _ in 0..4000 {
|
||||
@@ -309,7 +313,7 @@ fn arc_endpoints_and_sampling_are_consistent() {
|
||||
assert!(pt_eq(a.at(0.0), a.start_point(), 1e-9), "at(0) != start_point");
|
||||
assert!(pt_eq(a.at(1.0), a.end_point(), 1e-9), "at(1) != end_point");
|
||||
for k in 0..=10 {
|
||||
let t = k as f64 / 10.0;
|
||||
let t = f64::from(k) / 10.0;
|
||||
let p = a.at(t);
|
||||
assert!(p.x.is_finite() && p.y.is_finite(), "arc sample not finite at t={t}: {p:?}");
|
||||
assert!(on_circle(p, a.center, a.radius, 1e-9), "arc sample at t={t} off the circle: {p:?}");
|
||||
|
||||
@@ -44,6 +44,10 @@ pub struct Island {
|
||||
pub sources: Vec<usize>,
|
||||
}
|
||||
|
||||
#[expect(
|
||||
clippy::cast_possible_truncation,
|
||||
reason = "Rounded tolerance-bin coordinates intentionally use the defined saturating f64-to-i64 conversion."
|
||||
)]
|
||||
fn key(p: Vec2, origin: Vec2, q: f64) -> (i64, i64) {
|
||||
// The drawing may be georeferenced far from (0, 0). Quantizing absolute
|
||||
// coordinates saturates i64 and aliases distinct vertices into one key.
|
||||
@@ -90,6 +94,12 @@ fn pair_splits(segs: &[(Vec2, Vec2)], bb: &Bounds2) -> Option<Vec<Vec<f64>>> {
|
||||
|
||||
/// `pair_splits` with explicit budgets: `None` once more than `max_visits` candidate pairs were visited
|
||||
/// or more than `max_pairs` distinct pairs were tested.
|
||||
#[expect(
|
||||
clippy::cast_precision_loss,
|
||||
clippy::cast_possible_truncation,
|
||||
clippy::cast_sign_loss,
|
||||
reason = "At most 60,000 segments and 512 grid cells bound the numeric conversions; cell coordinates are clamped before casting."
|
||||
)]
|
||||
fn pair_splits_limited(segs: &[(Vec2, Vec2)], bb: &Bounds2, max_visits: u64, max_pairs: usize) -> Option<Vec<Vec<f64>>> {
|
||||
let n = segs.len();
|
||||
let cells = ((n as f64).sqrt().ceil() as usize).clamp(1, 512);
|
||||
@@ -333,6 +343,7 @@ fn points(g: &Graph, ids: &[usize]) -> Option<Vec<Vec2>> {
|
||||
}
|
||||
|
||||
/// The face around `p`, as vertex indices (counter-clockwise).
|
||||
#[expect(clippy::many_single_char_names, reason = "Ray/edge traversal keeps conventional graph and point notation.")]
|
||||
fn outer_face(g: &Graph, p: Vec2) -> Option<Vec<usize>> {
|
||||
// Try hits along a ray to +X from nearest outward, so nested faces resolve to the innermost.
|
||||
let mut hits: Vec<(f64, usize, usize)> = Vec::new();
|
||||
@@ -431,6 +442,11 @@ fn outside(core: &Graph, u: usize, steps: usize) -> Option<Vec<Vec2>> {
|
||||
}
|
||||
|
||||
/// Outlines of the groups of curves inside the face `outer` (vertex indices into `g`).
|
||||
#[expect(
|
||||
clippy::float_cmp,
|
||||
clippy::many_single_char_names,
|
||||
reason = "Exact x equality is required for the deterministic lexicographic tie-break; graph equations keep their conventional short names."
|
||||
)]
|
||||
fn islands(g: &Graph, outer: &[usize], p: Vec2) -> Option<Vec<Island>> {
|
||||
let comp = components(g);
|
||||
let outer_comp: std::collections::HashSet<usize> = outer.iter().filter_map(|&i| comp.get(i).copied()).collect();
|
||||
@@ -503,6 +519,7 @@ fn islands(g: &Graph, outer: &[usize], p: Vec2) -> Option<Vec<Island>> {
|
||||
/// The point of the nearest other curve within `snap` of the end `e` of curve `i`, as (curve,
|
||||
/// segment, parameter, point). `None` when the end touches a curve, or none is near. `Err` when
|
||||
/// the budget of segment checks runs out.
|
||||
#[expect(clippy::many_single_char_names, reason = "Nearest-point search keeps conventional i/j/k/a/b/t/q/d geometry notation.")]
|
||||
fn nearest_curve(polys: &[Vec<Vec2>], i: usize, e: Vec2, snap: f64, tol: f64, budget: &mut usize) -> Result<Option<(usize, usize, f64, Vec2)>, ()> {
|
||||
let mut best: Option<(f64, usize, usize, f64, Vec2)> = None;
|
||||
let mut touching = false;
|
||||
@@ -546,6 +563,7 @@ fn nearest_curve(polys: &[Vec<Vec2>], i: usize, e: Vec2, snap: f64, tol: f64, bu
|
||||
/// curve (which gains a vertex there), so the two meet exactly. A curve that is flattened
|
||||
/// into chords (an ellipse, a spline) lies up to the flattening tolerance off the true curve,
|
||||
/// so a line that ends on the true curve can stop just short of the chords.
|
||||
#[expect(clippy::many_single_char_names, reason = "Endpoint snapping keeps conventional polyline, segment and point notation.")]
|
||||
pub fn snap_ends(polys: &[Vec<Vec2>], snap: f64, tol: f64) -> Vec<Vec<Vec2>> {
|
||||
let mut out: Vec<Vec<Vec2>> = polys.to_vec();
|
||||
if !(snap.is_finite() && snap > tol) {
|
||||
@@ -626,6 +644,7 @@ pub fn boundary_at_gap(polys: &[Vec<Vec2>], p: Vec2, tol: f64, gap: f64) -> Opti
|
||||
/// The outside outline of curves that together enclose an area (counter-clockwise, dangling
|
||||
/// ends removed), or `None` when they enclose nothing or form more than one separate group.
|
||||
/// Gaps of up to `gap` between curve ends are closed (HPGAPTOL).
|
||||
#[expect(clippy::float_cmp, reason = "Exact x equality is required for the deterministic lexicographic tie-break.")]
|
||||
pub fn outline(polys: &[Vec<Vec2>], tol: f64, gap: f64) -> Option<Vec<Vec2>> {
|
||||
let g = build_gap(polys, tol, gap)?;
|
||||
let core = prune(&g);
|
||||
@@ -869,6 +888,7 @@ mod tests {
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[expect(clippy::cast_precision_loss, reason = "The test generates 17,000 segments, so every grid index is exact as f64.")]
|
||||
fn long_segment_crossing_in_unsampled_cell_is_split() {
|
||||
// A diagonal long enough to skip the grid, and a short segment crossing it in a cell the old coarse sampling missed.
|
||||
let mut polys = vec![vec![Vec2::new(0.0, 0.0), Vec2::new(1000.0, 1000.0)], vec![Vec2::new(11.0, 12.0), Vec2::new(12.0, 11.0)]];
|
||||
@@ -943,7 +963,7 @@ mod tests {
|
||||
}
|
||||
|
||||
fn lines_of(poly: &[Vec2]) -> Vec<Vec<Vec2>> {
|
||||
poly.windows(2).map(|w| w.to_vec()).collect()
|
||||
poly.windows(2).map(<[Vec2]>::to_vec).collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -1096,6 +1116,7 @@ mod tests {
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[expect(clippy::cast_precision_loss, reason = "The test is capped at MAX_SEGMENTS (60,000), so every generated coordinate is exact as f64.")]
|
||||
fn snap_ends_skips_input_over_the_segment_cap() {
|
||||
let mut polys: Vec<Vec<Vec2>> = (0..=MAX_SEGMENTS)
|
||||
.map(|i| {
|
||||
|
||||
@@ -6,7 +6,7 @@ use crate::{Bounds2, Vec2};
|
||||
/// Largest B-spline degree treated as valid. Basis evaluation is O(degree²) per sample and
|
||||
/// tessellation takes O(degree) samples, so an unbounded degree (DXF/HATCH can declare up to
|
||||
/// 100 000) turns a tiny spline into billions of iterations (CWE-407). Real splines are low
|
||||
/// degree (AutoCAD caps at 11); above this a spline evaluates to its control polygon instead.
|
||||
/// degree (`AutoCAD` caps at 11); above this a spline evaluates to its control polygon instead.
|
||||
pub const MAX_DEGREE: usize = 64;
|
||||
|
||||
/// A (possibly rational) B-spline curve, DXF SPLINE style.
|
||||
@@ -87,6 +87,7 @@ impl Spline {
|
||||
|
||||
/// `eval` on a spline `is_valid` has accepted, given its `domain()`, so sampling many points
|
||||
/// validates once (`is_valid` walks the knot vector).
|
||||
#[expect(clippy::many_single_char_names, reason = "De Boor evaluation keeps the standard p/w/b/k notation shared with basis_ref.")]
|
||||
fn eval_valid(&self, t: f64, lo: f64, hi: f64) -> Vec2 {
|
||||
let n = self.control.len().saturating_sub(1);
|
||||
let t = t.clamp(lo, hi);
|
||||
@@ -128,16 +129,22 @@ impl Spline {
|
||||
|
||||
/// The segments for a control polygon `ratio` times the tolerance: dimensionless, so a
|
||||
/// spline and its scaled copy sample alike at any scale.
|
||||
#[expect(
|
||||
clippy::cast_possible_truncation,
|
||||
clippy::cast_sign_loss,
|
||||
reason = "The floating count is clamped to 8..=2000 before its truncating conversion to usize."
|
||||
)]
|
||||
fn segments_for(&self, ratio: f64) -> usize {
|
||||
let n = (ratio.sqrt() * 2.0).clamp(8.0, 2000.0) as usize * self.degree.max(1);
|
||||
n.min(MAX_SAMPLES)
|
||||
}
|
||||
|
||||
fn polygon_length(&self) -> f64 {
|
||||
self.control.windows(2).map(|w| w.first().zip(w.get(1)).map(|(a, b)| a.dist(*b)).unwrap_or(0.0)).sum()
|
||||
self.control.windows(2).map(|w| w.first().zip(w.get(1)).map_or(0.0, |(a, b)| a.dist(*b))).sum()
|
||||
}
|
||||
|
||||
/// `n + 1` points evenly spaced in parameter over the domain (the spline must be valid).
|
||||
#[expect(clippy::cast_precision_loss, reason = "Internal callers cap sample counts at MAX_SAMPLES (4000), so every index is exact as f64.")]
|
||||
fn samples(&self, n: usize) -> impl Iterator<Item = Vec2> + '_ {
|
||||
let (lo, hi) = self.domain();
|
||||
(0..=n).map(move |i| self.eval_valid(lo + (hi - lo) * i as f64 / n as f64, lo, hi))
|
||||
@@ -159,6 +166,12 @@ impl Spline {
|
||||
/// is its control polygon, so its control box is exact; a degenerate spline gets its control
|
||||
/// box, which contains the curve (the box of the finite control points when one is not
|
||||
/// finite: `hull` skips it, but it would poison every sample).
|
||||
#[expect(
|
||||
clippy::cast_precision_loss,
|
||||
clippy::cast_possible_truncation,
|
||||
clippy::cast_sign_loss,
|
||||
reason = "Budgets and per-span counts are capped at MAX_SAMPLES; span fractions are nonnegative before conversion."
|
||||
)]
|
||||
pub fn bounds(&self) -> Bounds2 {
|
||||
let hull = Bounds2::from_points(self.control.iter().copied());
|
||||
let diag = hull.min.dist(hull.max);
|
||||
@@ -275,6 +288,10 @@ impl Spline {
|
||||
/// control points took minutes).
|
||||
const MAX_SAMPLES: usize = 4000;
|
||||
|
||||
#[expect(
|
||||
clippy::cast_precision_loss,
|
||||
reason = "Knot indices are sampled as normalized f64 parameters; any precision loss would only be beyond 2^53 allocated control points."
|
||||
)]
|
||||
pub(crate) fn clamped_uniform_knots(n: usize, degree: usize) -> Vec<f64> {
|
||||
let mut k = vec![0.0; degree + 1];
|
||||
let inner = n.saturating_sub(degree + 1);
|
||||
@@ -292,7 +309,7 @@ pub(crate) fn find_span(n: usize, p: usize, u: f64, knots: &[f64]) -> usize {
|
||||
}
|
||||
let mut low = p;
|
||||
let mut high = n + 1;
|
||||
let mut mid = (low + high) / 2;
|
||||
let mut mid = usize::midpoint(low, high);
|
||||
let mut guard = 0;
|
||||
while guard < 200 {
|
||||
guard += 1;
|
||||
@@ -305,7 +322,7 @@ pub(crate) fn find_span(n: usize, p: usize, u: f64, knots: &[f64]) -> usize {
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
mid = (low + high) / 2;
|
||||
mid = usize::midpoint(low, high);
|
||||
}
|
||||
mid
|
||||
}
|
||||
@@ -325,6 +342,11 @@ pub(crate) fn basis(span: usize, u: f64, p: usize, knots: &[f64]) -> Vec<f64> {
|
||||
|
||||
/// `basis` into `n[..=p]`, with `left` and `right` as scratch; each must hold `p + 1` values or
|
||||
/// `n` stays as it was.
|
||||
#[expect(
|
||||
clippy::cast_possible_wrap,
|
||||
clippy::cast_sign_loss,
|
||||
reason = "Spline indices are bounded by slice lengths, and max(0) makes the converted index nonnegative."
|
||||
)]
|
||||
fn basis_into(span: usize, u: f64, p: usize, knots: &[f64], n: &mut [f64], left: &mut [f64], right: &mut [f64]) {
|
||||
if n.len() <= p || left.len() <= p || right.len() <= p {
|
||||
return;
|
||||
@@ -358,6 +380,7 @@ fn basis_into(span: usize, u: f64, p: usize, knots: &[f64], n: &mut [f64], left:
|
||||
/// NaN, infinity or magnitudes above `1e100` (which could overflow) takes the full sweep, and so
|
||||
/// does a back-substitution row whose banded sum is zero (skipped zero terms can flip its sign).
|
||||
#[allow(clippy::needless_range_loop)]
|
||||
#[expect(clippy::many_single_char_names, reason = "Gaussian elimination keeps conventional matrix/row/column notation.")]
|
||||
pub(crate) fn solve(mut a: Vec<Vec<f64>>, mut b: Vec<f64>) -> Option<Vec<f64>> {
|
||||
#[cfg(test)]
|
||||
if tests::DENSE_ORACLE.get() {
|
||||
|
||||
@@ -1,6 +1,11 @@
|
||||
use super::*;
|
||||
|
||||
/// `basis` before it evaluated on the stack, kept as the reference.
|
||||
#[expect(
|
||||
clippy::cast_possible_wrap,
|
||||
clippy::cast_sign_loss,
|
||||
reason = "Spline indices are bounded by slice lengths, and max(0) makes the converted index nonnegative."
|
||||
)]
|
||||
fn basis_ref(span: usize, u: f64, p: usize, knots: &[f64]) -> Vec<f64> {
|
||||
let mut n = vec![0.0; p + 1];
|
||||
let mut left = vec![0.0; p + 1];
|
||||
@@ -23,6 +28,7 @@ fn basis_ref(span: usize, u: f64, p: usize, knots: &[f64]) -> Vec<f64> {
|
||||
}
|
||||
|
||||
/// `eval` before it evaluated on the stack, kept as the reference.
|
||||
#[expect(clippy::many_single_char_names, reason = "The reference implementation keeps the NURBS equation notation used by the algorithm under test.")]
|
||||
fn eval_ref(s: &Spline, t: f64) -> Vec2 {
|
||||
let n = s.control.len() - 1;
|
||||
let (lo, hi) = s.domain();
|
||||
@@ -41,21 +47,26 @@ fn eval_ref(s: &Spline, t: f64) -> Vec2 {
|
||||
}
|
||||
|
||||
/// Deterministic pseudo-random numbers in `0..1`.
|
||||
#[expect(clippy::cast_precision_loss, reason = "The generator keeps exactly 53 random bits, and 2^53 is exactly representable as f64.")]
|
||||
fn noise(seed: &mut u64) -> f64 {
|
||||
*seed = seed.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);
|
||||
*seed = seed.wrapping_mul(6_364_136_223_846_793_005).wrapping_add(1_442_695_040_888_963_407);
|
||||
(*seed >> 11) as f64 / (1u64 << 53) as f64
|
||||
}
|
||||
|
||||
/// Splines of degree 1..=11 over 14 control points: clamped and unclamped (uniform) knots,
|
||||
/// unit and random weights.
|
||||
#[expect(
|
||||
clippy::cast_precision_loss,
|
||||
reason = "The test uses 14 control points and degrees through 11, so every knot index is exactly representable as f64."
|
||||
)]
|
||||
fn samples() -> Vec<Spline> {
|
||||
let mut seed = 7;
|
||||
let mut out = Vec::new();
|
||||
for degree in 1..=11 {
|
||||
let control: Vec<Vec2> = (0..14).map(|i| Vec2::new(i as f64 * 3.0 + noise(&mut seed), 10.0 * noise(&mut seed) - 5.0)).collect();
|
||||
let control: Vec<Vec2> = (0..14).map(|i| Vec2::new(f64::from(i) * 3.0 + noise(&mut seed), 10.0 * noise(&mut seed) - 5.0)).collect();
|
||||
let weights: Vec<f64> = (0..14).map(|_| 0.5 + 1.5 * noise(&mut seed)).collect();
|
||||
let clamped = Spline::from_control(control.clone(), degree);
|
||||
let uniform = Spline { knots: (0..control.len() + degree + 1).map(|i| i as f64 * 0.25).collect(), ..clamped.clone() };
|
||||
let uniform = Spline { knots: (0..=(control.len() + degree)).map(|i| i as f64 * 0.25).collect(), ..clamped.clone() };
|
||||
for base in [clamped, uniform] {
|
||||
out.push(Spline { weights: weights.clone(), ..base.clone() });
|
||||
out.push(base);
|
||||
@@ -70,7 +81,7 @@ fn stack_basis_matches_the_heap_basis_bit_for_bit() {
|
||||
assert!(s.is_valid());
|
||||
let (lo, hi) = s.domain();
|
||||
for i in -20..=1020 {
|
||||
let t = lo + (hi - lo) * i as f64 / 1000.0;
|
||||
let t = lo + (hi - lo) * f64::from(i) / 1000.0;
|
||||
let got = s.eval(t);
|
||||
let want = eval_ref(&s, t);
|
||||
assert_eq!((got.x.to_bits(), got.y.to_bits()), (want.x.to_bits(), want.y.to_bits()), "degree {} at {t}: {got:?} vs {want:?}", s.degree);
|
||||
@@ -87,14 +98,14 @@ fn basis_into_needs_room_for_every_function() {
|
||||
let knots = clamped_uniform_knots(6, 3);
|
||||
let (mut n, mut left, mut right) = ([0.5; 3], [0.0; 4], [0.0; 4]);
|
||||
basis_into(3, 0.5, 3, &knots, &mut n, &mut left, &mut right);
|
||||
assert_eq!(n, [0.5; 3]);
|
||||
assert_eq!(n.map(f64::to_bits), [0.5; 3].map(f64::to_bits));
|
||||
}
|
||||
|
||||
/// A cubic through 300 points of a sine wave, open or closed.
|
||||
fn wiggly(closed: bool) -> Spline {
|
||||
let fit: Vec<Vec2> = (0..300)
|
||||
.map(|i| {
|
||||
let x = i as f64 / 299.0;
|
||||
let x = f64::from(i) / 299.0;
|
||||
Vec2::new(x * 100.0, 10.0 * (x * 60.0).sin())
|
||||
})
|
||||
.collect();
|
||||
@@ -108,6 +119,7 @@ fn fine_box(s: &Spline) -> Bounds2 {
|
||||
|
||||
/// The box of `n + 1` samples evenly spaced in parameter over the domain, as `bounds` sampled
|
||||
/// before it spread its samples over the knot spans.
|
||||
#[expect(clippy::cast_precision_loss, reason = "Test grids are capped at MAX_SAMPLES (4000), so sample indices are exactly representable as f64.")]
|
||||
fn uniform_box(s: &Spline, n: usize) -> Bounds2 {
|
||||
let (lo, hi) = s.domain();
|
||||
Bounds2::from_points((0..=n).map(|i| s.eval(lo + (hi - lo) * i as f64 / n as f64)))
|
||||
@@ -118,7 +130,7 @@ fn uniform_box(s: &Spline, n: usize) -> Bounds2 {
|
||||
/// except for a peak of 50 at t = 0.50035, inside a span of width 1e-4 that no point of a
|
||||
/// uniform grid of up to 4000 hits (0.50025 and 0.5005 are the nearest).
|
||||
fn narrow_span() -> Spline {
|
||||
let control = (0..7).map(|i| Vec2::new(i as f64, if i == 3 { 100.0 } else { 0.0 })).collect();
|
||||
let control = (0..7).map(|i| Vec2::new(f64::from(i), if i == 3 { 100.0 } else { 0.0 })).collect();
|
||||
Spline { degree: 2, knots: vec![0.0, 0.0, 0.0, 0.5003, 0.5003, 0.5004, 0.5004, 1.0, 1.0, 1.0], control, ..Spline::default() }
|
||||
}
|
||||
|
||||
@@ -132,14 +144,14 @@ fn an_off_grid_peak_in_a_narrow_span_is_within_a_percent() {
|
||||
s.control[4].y = 30.0;
|
||||
assert!(s.is_valid());
|
||||
let (a, b) = (0.5003, 0.5004);
|
||||
let peak = (0..=10_000).map(|i| s.eval(a + (b - a) * i as f64 / 10_000.0)).fold(Vec2::ZERO, |m, p| if p.y > m.y { p } else { m });
|
||||
let peak = (0..=10_000).map(|i| s.eval(a + (b - a) * f64::from(i) / 10_000.0)).fold(Vec2::ZERO, |m, p| if p.y > m.y { p } else { m });
|
||||
assert!(peak.y > 58.0 && peak.y < 59.0, "{peak:?}");
|
||||
let hull = Bounds2::from_points(s.control.iter().copied());
|
||||
let diag = hull.min.dist(hull.max);
|
||||
let got = s.bounds();
|
||||
assert!(got.max.y <= peak.y + 1e-9 * diag && got.max.y >= peak.y - 1e-2 * diag, "{got:?} vs peak {peak:?}");
|
||||
// Four segments, the floor before, missed it by more than that.
|
||||
let four = (0..=4).map(|i| s.eval(a + (b - a) * i as f64 / 4.0)).fold(f64::MIN, |m, p| m.max(p.y));
|
||||
let four = (0..=4).map(|i| s.eval(a + (b - a) * f64::from(i) / 4.0)).fold(f64::MIN, |m, p| m.max(p.y));
|
||||
assert!(four < peak.y - 1e-2 * diag, "{four} vs {peak:?}");
|
||||
}
|
||||
|
||||
@@ -148,7 +160,7 @@ fn bounds_see_an_extreme_inside_a_narrow_knot_span() {
|
||||
let s = narrow_span();
|
||||
assert!(s.is_valid());
|
||||
let (a, b) = (0.5003, 0.5004);
|
||||
let peak = (0..=1000).map(|i| s.eval(a + (b - a) * i as f64 / 1000.0)).fold(Vec2::ZERO, |m, p| if p.y > m.y { p } else { m });
|
||||
let peak = (0..=1000).map(|i| s.eval(a + (b - a) * f64::from(i) / 1000.0)).fold(Vec2::ZERO, |m, p| if p.y > m.y { p } else { m });
|
||||
assert!((peak.x - 3.0).abs() < 1e-9 && (peak.y - 50.0).abs() < 1e-9, "{peak:?}");
|
||||
let hull = Bounds2::from_points(s.control.iter().copied());
|
||||
let diag = hull.min.dist(hull.max);
|
||||
@@ -165,6 +177,7 @@ fn bounds_see_an_extreme_inside_a_narrow_knot_span() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[expect(clippy::cast_precision_loss, reason = "The test grids contain 1502 or 2502 points, so all sample indices are exact as f64.")]
|
||||
fn bounds_keep_their_cap_over_many_spans() {
|
||||
// 1500 spans: eight per span would pass the cap, so two; 2500 spans: more than the cap
|
||||
// allows two for, so the control box, which contains the curve. A smooth curve stays
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
//! Fit-point splines: knot parametrisation (chord, square root, uniform), end tangents and fit
|
||||
//! tolerance (least-squares approximation with fewer control points), as AutoCAD's SPLINE Fit
|
||||
//! tolerance (least-squares approximation with fewer control points), as `AutoCAD`'s SPLINE Fit
|
||||
//! method offers them. Construction follows the textbook global interpolation and approximation
|
||||
//! schemes (Piegl & Tiller, *The NURBS Book*, ch. 9).
|
||||
|
||||
@@ -110,17 +110,16 @@ impl Spline {
|
||||
pub fn fit_with(fit: &[Vec2], closed: bool, opts: FitOptions) -> Spline {
|
||||
let opts = opts.sanitized();
|
||||
let kinked = if fit.len() <= MAX_KINK_POINTS { kinked_fit(fit, closed, opts) } else { None };
|
||||
let mut s = match kinked {
|
||||
Some(s) => s,
|
||||
None => {
|
||||
// Repeats at the ends of an open curve are no corners: fit without them.
|
||||
let (pts, _) = kinks(fit, false);
|
||||
let mut s = if closed { closed_fit(&pts, opts.knots, opts.tolerance) } else { open_fit(&pts, opts) };
|
||||
if pts.len() != fit.len() && !closed {
|
||||
s.fit = fit.to_vec();
|
||||
}
|
||||
s
|
||||
let mut s = if let Some(s) = kinked {
|
||||
s
|
||||
} else {
|
||||
// Repeats at the ends of an open curve are no corners: fit without them.
|
||||
let (pts, _) = kinks(fit, false);
|
||||
let mut s = if closed { closed_fit(&pts, opts.knots, opts.tolerance) } else { open_fit(&pts, opts) };
|
||||
if pts.len() != fit.len() && !closed {
|
||||
s.fit = fit.to_vec();
|
||||
}
|
||||
s
|
||||
};
|
||||
s.fit_opts = if closed { FitOptions { start_tangent: None, end_tangent: None, ..opts } } else { opts };
|
||||
s
|
||||
@@ -210,19 +209,19 @@ pub(crate) fn params(pts: &[Vec2], kind: KnotParam, closed: bool) -> Vec<f64> {
|
||||
let mut u = vec![0.0; count];
|
||||
let mut total = 0.0;
|
||||
for i in 1..count {
|
||||
total += pts.get(i - 1).zip(pts.get(i % n.max(1))).map(|(a, b)| kind.step(a.dist(*b))).unwrap_or(1.0);
|
||||
total += pts.get(i - 1).zip(pts.get(i % n.max(1))).map_or(1.0, |(a, b)| kind.step(a.dist(*b)));
|
||||
if let Some(x) = u.get_mut(i) {
|
||||
*x = total;
|
||||
}
|
||||
}
|
||||
for x in u.iter_mut() {
|
||||
for x in &mut u {
|
||||
*x /= total.max(1e-300);
|
||||
}
|
||||
u
|
||||
}
|
||||
|
||||
fn chord_length(pts: &[Vec2]) -> f64 {
|
||||
pts.windows(2).map(|w| w.first().zip(w.get(1)).map(|(a, b)| a.dist(*b)).unwrap_or(0.0)).sum()
|
||||
pts.windows(2).map(|w| w.first().zip(w.get(1)).map_or(0.0, |(a, b)| a.dist(*b))).sum()
|
||||
}
|
||||
|
||||
fn open_fit(fit: &[Vec2], opts: FitOptions) -> Spline {
|
||||
@@ -262,6 +261,11 @@ fn open_fit(fit: &[Vec2], opts: FitOptions) -> Spline {
|
||||
/// Global interpolation: one control point per fit point plus one per end-derivative
|
||||
/// constraint, knots by averaging the parameters (an end with a derivative counts its
|
||||
/// parameter twice).
|
||||
#[expect(
|
||||
clippy::cast_precision_loss,
|
||||
clippy::many_single_char_names,
|
||||
reason = "Interpolation uses NURBS matrix notation, and its degree is capped at three, so p is exact as f64."
|
||||
)]
|
||||
fn interpolate(fit: &[Vec2], u: &[f64], d0: Option<Vec2>, d1: Option<Vec2>) -> Option<Spline> {
|
||||
let (p, knots) = interp_knots(u, d0.is_some(), d1.is_some());
|
||||
let m = knots.len().checked_sub(p + 1)?;
|
||||
@@ -305,6 +309,7 @@ fn interpolate(fit: &[Vec2], u: &[f64], d0: Option<Vec2>, d1: Option<Vec2>) -> O
|
||||
|
||||
/// Degree and clamped knots for interpolating at parameters `u`, with optional end derivatives:
|
||||
/// knots average the parameters, an end with a derivative counting its parameter twice.
|
||||
#[expect(clippy::cast_precision_loss, reason = "The interpolation degree is capped at three, so p is exact as f64.")]
|
||||
fn interp_knots(u: &[f64], d0: bool, d1: bool) -> (usize, Vec<f64>) {
|
||||
let m = u.len() + usize::from(d0) + usize::from(d1);
|
||||
let p = 3.min(m.saturating_sub(1)).max(1);
|
||||
@@ -323,6 +328,13 @@ fn interp_knots(u: &[f64], d0: bool, d1: bool) -> (usize, Vec<f64>) {
|
||||
|
||||
/// Clamped knots for a least-squares fit with `m` control points of degree `p` so every span
|
||||
/// holds parameters (The NURBS Book eq. 9.69). Needs `p < m < u.len()`.
|
||||
#[expect(
|
||||
clippy::cast_precision_loss,
|
||||
clippy::cast_possible_truncation,
|
||||
clippy::cast_sign_loss,
|
||||
clippy::many_single_char_names,
|
||||
reason = "Fit sizes are bounded by MAX_APPROX_POINTS, knot indices are nonnegative and clamped, and the equations use NURBS Book notation."
|
||||
)]
|
||||
fn lsq_knots(u: &[f64], m: usize, p: usize) -> Vec<f64> {
|
||||
let n = u.len();
|
||||
let d = n as f64 / m.saturating_sub(p).max(1) as f64;
|
||||
@@ -339,12 +351,18 @@ fn lsq_knots(u: &[f64], m: usize, p: usize) -> Vec<f64> {
|
||||
|
||||
/// Periodic knots for `n` points with closed parameters `t` (`n + 1` values): knots[j] =
|
||||
/// t_(j-p), extended by whole periods on both sides.
|
||||
#[expect(
|
||||
clippy::cast_precision_loss,
|
||||
clippy::cast_possible_wrap,
|
||||
clippy::many_single_char_names,
|
||||
reason = "Indices are bounded by slice lengths, period offsets are f64 by design, and the periodic equations use standard notation."
|
||||
)]
|
||||
fn periodic_knots(t: &[f64], n: usize, p: usize) -> Vec<f64> {
|
||||
let tk = |i: isize| {
|
||||
let (q, r) = (i.div_euclid(n.max(1) as isize), i.rem_euclid(n.max(1) as isize) as usize);
|
||||
t.get(r).copied().unwrap_or(0.0) + q as f64
|
||||
};
|
||||
(0..n + 2 * p + 1).map(|j| tk(j as isize - p as isize)).collect()
|
||||
(0..=(n + 2 * p)).map(|j| tk(j as isize - p as isize)).collect()
|
||||
}
|
||||
|
||||
/// Least-squares approximation within `tol`: the fewest control points (searched by bisection)
|
||||
@@ -357,7 +375,7 @@ fn approximate(fit: &[Vec2], u: &[f64], d0: Option<Vec2>, d1: Option<Vec2>, tol:
|
||||
let (mut lo, mut hi) = (p + 1, n.checked_sub(1)?);
|
||||
let mut best = None;
|
||||
while lo <= hi {
|
||||
let mid = (lo + hi) / 2;
|
||||
let mid = usize::midpoint(lo, hi);
|
||||
match least_squares(fit, u, mid, p, d0, d1) {
|
||||
Some(s) if max_deviation(&s, fit, u) <= tol => {
|
||||
best = Some(s);
|
||||
@@ -373,6 +391,11 @@ fn max_deviation(s: &Spline, fit: &[Vec2], u: &[f64]) -> f64 {
|
||||
fit.iter().zip(u).map(|(q, t)| s.eval(*t).dist(*q)).fold(0.0, f64::max)
|
||||
}
|
||||
|
||||
#[expect(
|
||||
clippy::cast_precision_loss,
|
||||
clippy::many_single_char_names,
|
||||
reason = "Open least-squares fitting is cubic and keeps the NURBS Book matrix notation, so p is exact as f64."
|
||||
)]
|
||||
fn least_squares(fit: &[Vec2], u: &[f64], m: usize, p: usize, d0: Option<Vec2>, d1: Option<Vec2>) -> Option<Spline> {
|
||||
let n = fit.len();
|
||||
if m <= p || m >= n {
|
||||
@@ -522,6 +545,11 @@ fn kinked_fit(fit: &[Vec2], closed: bool, opts: FitOptions) -> Option<Spline> {
|
||||
|
||||
/// A clamped, non-rational fitted piece raised to degree 3: interpolation through two or three
|
||||
/// points gives a single Bézier segment of lower degree, which is raised exactly.
|
||||
#[expect(
|
||||
clippy::cast_precision_loss,
|
||||
clippy::many_single_char_names,
|
||||
reason = "Degree elevation stops at three and keeps the Bézier coefficient notation, so all indices are exact as f64."
|
||||
)]
|
||||
fn cubic(mut s: Spline) -> Option<Spline> {
|
||||
if s.degree == 3 {
|
||||
return Some(s);
|
||||
@@ -555,7 +583,7 @@ fn approximate_closed(pts: &[Vec2], t: &[f64], p: usize, tol: f64) -> Option<Spl
|
||||
let (mut lo, mut hi) = (p + 1, n.checked_sub(1)?);
|
||||
let mut best = None;
|
||||
while lo <= hi {
|
||||
let mid = (lo + hi) / 2;
|
||||
let mid = usize::midpoint(lo, hi);
|
||||
match periodic_least_squares(pts, t, mid, p) {
|
||||
Some(s) if pts.iter().zip(t).all(|(q, u)| s.eval(*u).dist(*q) <= tol) => {
|
||||
best = Some(s);
|
||||
@@ -570,6 +598,13 @@ fn approximate_closed(pts: &[Vec2], t: &[f64], p: usize, tol: f64) -> Option<Spl
|
||||
/// A periodic spline with `m` distinct control points (`p < m < pts.len()`) closest in the
|
||||
/// least-squares sense to `pts` at closed parameters `t`. The period's breakpoints spread over
|
||||
/// the parameters so every span holds some (the closed counterpart of `lsq_knots`).
|
||||
#[expect(
|
||||
clippy::cast_precision_loss,
|
||||
clippy::cast_possible_truncation,
|
||||
clippy::cast_sign_loss,
|
||||
clippy::many_single_char_names,
|
||||
reason = "Fit sizes are bounded by MAX_APPROX_POINTS, periodic indices are nonnegative and bounded, and the matrix equations use standard notation."
|
||||
)]
|
||||
fn periodic_least_squares(pts: &[Vec2], t: &[f64], m: usize, p: usize) -> Option<Spline> {
|
||||
let n = pts.len();
|
||||
if m <= p || m >= n || t.len() != n + 1 {
|
||||
@@ -620,6 +655,7 @@ fn periodic_least_squares(pts: &[Vec2], t: &[f64], m: usize, p: usize) -> Option
|
||||
Some(Spline { degree: p, knots, control, fit: pts.to_vec(), closed: true, ..Spline::default() })
|
||||
}
|
||||
|
||||
#[expect(clippy::many_single_char_names, reason = "Closed interpolation keeps the NURBS Book parameter, degree and matrix notation.")]
|
||||
fn closed_fit(fit: &[Vec2], kind: KnotParam, tol: f64) -> Spline {
|
||||
let mut pts = fit.to_vec();
|
||||
if pts.len() > 3 && pts.first().zip(pts.last()).is_some_and(|(a, b)| a.near(*b, 1e-12)) {
|
||||
@@ -748,7 +784,7 @@ mod tests {
|
||||
// Thirty noisy points along a gentle arc.
|
||||
let fit: Vec<Vec2> = (0..30)
|
||||
.map(|i| {
|
||||
let t = i as f64 / 29.0;
|
||||
let t = f64::from(i) / 29.0;
|
||||
Vec2::new(t * 10.0, (t * 3.0).sin() * 2.0 + if i % 2 == 0 { 0.01 } else { -0.01 })
|
||||
})
|
||||
.collect();
|
||||
@@ -761,7 +797,7 @@ mod tests {
|
||||
assert!(max_deviation(&s, &fit, &u) <= tol + 1e-9);
|
||||
assert!(s.eval(0.0).near(fit[0], 1e-9) && s.eval(1.0).near(fit[29], 1e-9), "ends stay exact");
|
||||
assert_eq!(s.fit, fit, "the fit points are kept");
|
||||
assert_eq!(s.fit_opts.tolerance, tol);
|
||||
assert_eq!(s.fit_opts.tolerance.to_bits(), tol.to_bits());
|
||||
// With tangents too.
|
||||
let t = Spline::fit_with(
|
||||
&fit,
|
||||
@@ -781,7 +817,7 @@ mod tests {
|
||||
// Forty slightly noisy points round a circle.
|
||||
let fit: Vec<Vec2> = (0..40)
|
||||
.map(|i| {
|
||||
let a = i as f64 / 40.0 * std::f64::consts::TAU;
|
||||
let a = f64::from(i) / 40.0 * std::f64::consts::TAU;
|
||||
let r = 5.0 + if i % 2 == 0 { 0.01 } else { -0.01 };
|
||||
Vec2::new(a.cos() * r, a.sin() * r)
|
||||
})
|
||||
@@ -796,7 +832,7 @@ mod tests {
|
||||
let (lo, hi) = s.domain();
|
||||
assert!(s.eval(lo).near(s.eval(hi), 1e-9), "still closed");
|
||||
assert_eq!(s.fit, fit);
|
||||
assert_eq!(s.fit_opts.tolerance, tol);
|
||||
assert_eq!(s.fit_opts.tolerance.to_bits(), tol.to_bits());
|
||||
// Too tight a tolerance interpolates.
|
||||
let tiny = Spline::fit_with(&fit, true, FitOptions { tolerance: 1e-9, ..FitOptions::default() });
|
||||
assert_eq!(tiny.control.len(), exact.control.len());
|
||||
@@ -809,10 +845,14 @@ mod tests {
|
||||
|
||||
fn on_curve(s: &Spline, q: Vec2) -> bool {
|
||||
let (lo, hi) = s.domain();
|
||||
(0..=4000).any(|i| s.eval(lo + (hi - lo) * i as f64 / 4000.0).dist(q) < 1e-2)
|
||||
(0..=4000).any(|i| s.eval(lo + (hi - lo) * f64::from(i) / 4000.0).dist(q) < 1e-2)
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[expect(
|
||||
clippy::many_single_char_names,
|
||||
reason = "The test names spline values and points with the same short notation as the fitting equations."
|
||||
)]
|
||||
fn repeated_fit_points_make_kinks() {
|
||||
let fit = [Vec2::new(0.0, 0.0), Vec2::new(2.0, 2.0), Vec2::new(4.0, 0.0), Vec2::new(4.0, 0.0), Vec2::new(6.0, 2.0), Vec2::new(8.0, 0.0)];
|
||||
let s = Spline::fit_with(&fit, false, FitOptions::default());
|
||||
@@ -873,13 +913,17 @@ mod tests {
|
||||
let _ = Spline::fit_with(&pairs[..n], closed, FitOptions { tolerance: 0.1, ..FitOptions::default() });
|
||||
}
|
||||
}
|
||||
let tight: Vec<Vec2> = (0..8).map(|i| Vec2::new(i as f64 * 1e-13, 0.0)).collect();
|
||||
let tight: Vec<Vec2> = (0..8).map(|i| Vec2::new(f64::from(i) * 1e-13, 0.0)).collect();
|
||||
let _ = Spline::fit_with(&tight, true, FitOptions { tolerance: 1.0, ..FitOptions::default() });
|
||||
}
|
||||
|
||||
/// Above the interpolation cap the fit points become control points instead of a dense
|
||||
/// system the size of their count squared (issue #702); just below it they still interpolate.
|
||||
#[test]
|
||||
#[expect(
|
||||
clippy::cast_precision_loss,
|
||||
reason = "The generated test grids are bounded by MAX_INTERP_POINTS + 1, so their indices are exact as f64."
|
||||
)]
|
||||
fn too_many_fit_points_are_not_interpolated() {
|
||||
let wave = |n: usize| -> Vec<Vec2> { (0..n).map(|i| Vec2::new((i * i) as f64 * 1e-3, (i % 5) as f64)).collect() };
|
||||
let fit = wave(MAX_INTERP_POINTS + 1);
|
||||
|
||||
@@ -214,7 +214,7 @@ fn segment_offset() {
|
||||
let s = Segment::Arc { arc: Arc::new(Vec2::ZERO, 5.0, 0.0, PI), ccw: true };
|
||||
let o = s.offset(1.0).unwrap();
|
||||
if let Segment::Arc { arc, .. } = o {
|
||||
assert!(close(arc.radius, 4.0))
|
||||
assert!(close(arc.radius, 4.0));
|
||||
} else {
|
||||
panic!()
|
||||
}
|
||||
@@ -237,7 +237,7 @@ fn polyline_tessellation_is_bounded() {
|
||||
fn arc_segments_bounded() {
|
||||
assert_eq!(arc_segments(0.0, 1.0, 0.1), 1);
|
||||
assert!(arc_segments(1e9, TAU, 1e-12) <= 4096);
|
||||
assert!(arc_segments(f64::NAN, TAU, 0.1) == 1);
|
||||
assert_eq!(arc_segments(f64::NAN, TAU, 0.1), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -341,8 +341,8 @@ fn polyline_area_is_stable_far_from_the_origin() {
|
||||
fn shoelace_preserves_small_polygon_area_at_large_coordinates() {
|
||||
let o = 1.0e12;
|
||||
let corners = [Vec2::new(o, o), Vec2::new(o + 10.0, o), Vec2::new(o + 10.0, o + 10.0), Vec2::new(o, o + 10.0)];
|
||||
assert_eq!(shoelace(&corners), 100.0);
|
||||
assert_eq!(shoelace(&corners.iter().rev().copied().collect::<Vec<_>>()), -100.0);
|
||||
assert_eq!(shoelace(&corners).to_bits(), 100.0_f64.to_bits());
|
||||
assert_eq!(shoelace(&corners.iter().rev().copied().collect::<Vec<_>>()).to_bits(), (-100.0_f64).to_bits());
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -9,6 +9,8 @@ license.workspace = true
|
||||
workspace = true
|
||||
|
||||
[dependencies]
|
||||
craft-mcp = { workspace = true }
|
||||
craft-jsonrpc = { workspace = true }
|
||||
cadcraft-engine = { workspace = true }
|
||||
cadcraft-render = { workspace = true }
|
||||
cadcraft-io = { workspace = true }
|
||||
|
||||
+37
-48
@@ -22,25 +22,24 @@ Verify with inspect_drawing / query_entities and look with render.";
|
||||
|
||||
pub struct Server {
|
||||
backend: Box<dyn Backend>,
|
||||
initialized: bool,
|
||||
}
|
||||
|
||||
fn response(id: Value, result: Value) -> Value {
|
||||
json!({"jsonrpc": "2.0", "id": id, "result": result})
|
||||
}
|
||||
fn error(id: Value, code: i64, message: impl Into<String>) -> Value {
|
||||
json!({"jsonrpc": "2.0", "id": id, "error": {"code": code, "message": message.into()}})
|
||||
session: craft_mcp::Session,
|
||||
}
|
||||
|
||||
impl Server {
|
||||
pub fn new(backend: Box<dyn Backend>) -> Self {
|
||||
Self { backend, initialized: false }
|
||||
Self {
|
||||
backend,
|
||||
session: craft_mcp::Session::new("cadcraft", env!("CARGO_PKG_VERSION"), craft_mcp::Policy::Compatible)
|
||||
.with_capabilities(json!({"tools": {"listChanged": false}, "resources": {"listChanged": false}}))
|
||||
.unwrap_or_else(|_| craft_mcp::Session::new("cadcraft", env!("CARGO_PKG_VERSION"), craft_mcp::Policy::Compatible))
|
||||
.with_legacy_initialize(SUPPORTED, json!({"name": "cadcraft", "title": "CADCraft", "version": env!("CARGO_PKG_VERSION")})),
|
||||
}
|
||||
}
|
||||
pub fn backend(&mut self) -> &mut dyn Backend {
|
||||
self.backend.as_mut()
|
||||
}
|
||||
pub fn is_initialized(&self) -> bool {
|
||||
self.initialized
|
||||
self.session.is_initialized()
|
||||
}
|
||||
|
||||
/// Serve newline-delimited JSON-RPC until `input` closes (logs to stderr only).
|
||||
@@ -62,53 +61,43 @@ impl Server {
|
||||
return None;
|
||||
}
|
||||
let reply = match serde_json::from_str::<Value>(line) {
|
||||
// JSON-RPC 2.0: an empty batch is one Invalid Request, not silence.
|
||||
Ok(Value::Array(batch)) if batch.is_empty() => Some(error(Value::Null, INVALID_REQUEST, "empty batch")),
|
||||
Ok(Value::Array(batch)) => {
|
||||
let replies: Vec<Value> = batch.into_iter().filter_map(|m| self.handle(m)).collect();
|
||||
(!replies.is_empty()).then_some(Value::Array(replies))
|
||||
}
|
||||
Ok(msg) => self.handle(msg),
|
||||
Err(e) => Some(error(Value::Null, PARSE_ERROR, format!("parse error: {e}"))),
|
||||
Ok(msg) => self.handle_message(&msg),
|
||||
Err(e) => Some(craft_jsonrpc::error_response(Value::Null, craft_jsonrpc::RpcError::new(PARSE_ERROR, format!("parse error: {e}")))),
|
||||
};
|
||||
reply.map(|r| r.to_string())
|
||||
}
|
||||
|
||||
pub fn handle(&mut self, msg: Value) -> Option<Value> {
|
||||
let Value::Object(o) = &msg else { return Some(error(Value::Null, INVALID_REQUEST, "message must be an object")) };
|
||||
let id = o.get("id").cloned();
|
||||
let Some(method) = o.get("method").and_then(Value::as_str) else {
|
||||
if o.contains_key("result") || o.contains_key("error") {
|
||||
return None;
|
||||
}
|
||||
return Some(error(id.unwrap_or(Value::Null), INVALID_REQUEST, "missing `method`"));
|
||||
};
|
||||
let params = o.get("params").cloned().unwrap_or(Value::Null);
|
||||
let Some(id) = id else {
|
||||
if method == "notifications/initialized" {
|
||||
self.initialized = true;
|
||||
}
|
||||
return None;
|
||||
};
|
||||
Some(match self.request(method, ¶ms) {
|
||||
Ok(r) => response(id, r),
|
||||
Err((code, m)) => error(id, code, m),
|
||||
})
|
||||
// `handle` historically routes only one envelope; batches belong to `handle_line`.
|
||||
if msg.is_array() {
|
||||
return Some(craft_jsonrpc::error_response(Value::Null, craft_jsonrpc::RpcError::new(INVALID_REQUEST, "message must be an object")));
|
||||
}
|
||||
self.handle_message(&msg)
|
||||
}
|
||||
|
||||
fn handle_message(&mut self, msg: &Value) -> Option<Value> {
|
||||
let server = std::cell::RefCell::new(self);
|
||||
craft_jsonrpc::process_legacy(
|
||||
msg,
|
||||
|request| {
|
||||
let mut server = server.borrow_mut();
|
||||
if request.method == "initialize" {
|
||||
let instructions = format!("{INSTRUCTIONS} Backend: {}.", server.backend.describe());
|
||||
server.session.set_instructions(instructions);
|
||||
}
|
||||
if let Some(result) = server.session.request(request, msg.is_array()) {
|
||||
return result;
|
||||
}
|
||||
server
|
||||
.request(request.method, request.params.unwrap_or(&Value::Null))
|
||||
.map_err(|(code, message)| craft_jsonrpc::RpcError::new(code, message))
|
||||
},
|
||||
|request| server.borrow_mut().session.notification(request),
|
||||
)
|
||||
}
|
||||
|
||||
fn request(&mut self, method: &str, params: &Value) -> Result<Value, (i64, String)> {
|
||||
match method {
|
||||
"initialize" => {
|
||||
let asked = params.get("protocolVersion").and_then(Value::as_str).unwrap_or(PROTOCOL_VERSION);
|
||||
let version = if SUPPORTED.contains(&asked) { asked } else { PROTOCOL_VERSION };
|
||||
Ok(json!({
|
||||
"protocolVersion": version,
|
||||
"capabilities": {"tools": {"listChanged": false}, "resources": {"listChanged": false}},
|
||||
"serverInfo": {"name": "cadcraft", "title": "CADCraft", "version": env!("CARGO_PKG_VERSION")},
|
||||
"instructions": format!("{INSTRUCTIONS} Backend: {}.", self.backend.describe()),
|
||||
}))
|
||||
}
|
||||
"ping" => Ok(json!({})),
|
||||
"tools/list" => Ok(tool_definitions(self.backend.has_ui())),
|
||||
"tools/call" => {
|
||||
let name = params.get("name").and_then(Value::as_str).ok_or((INVALID_PARAMS, "missing tool `name`".to_string()))?;
|
||||
|
||||
@@ -391,3 +391,24 @@ fn render_refuses_unknown_backgrounds_and_plot_styles() {
|
||||
assert!(crate::Backend::call(&mut h, "ui.render", json!({"background": "purple"})).is_err());
|
||||
assert!(crate::Backend::call(&mut h, "ui.render", json!({"plot_style": 3})).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn legacy_protocol_routing_and_version_negotiation() {
|
||||
let mut s = Server::new(Box::new(Headless::default()));
|
||||
assert!(s.handle_line(r#"{"method":"notifications/initialized"}"#).is_none());
|
||||
assert!(s.is_initialized());
|
||||
for (params, expected) in
|
||||
[(json!(null), "2025-06-18"), (json!({"protocolVersion":"2024-11-05"}), "2024-11-05"), (json!({"protocolVersion":"other"}), "2025-06-18")]
|
||||
{
|
||||
let response = call(&mut s, 1, "initialize", params);
|
||||
assert_eq!(response["result"]["protocolVersion"], expected);
|
||||
assert_eq!(response["result"]["serverInfo"]["title"], "CADCraft");
|
||||
assert!(response["result"]["instructions"].as_str().unwrap().contains("Backend:"));
|
||||
}
|
||||
let response: Value =
|
||||
serde_json::from_str(&s.handle_line(r#"[{"id":[1],"method":"ping","params":5},{"method":"ignored"},{"result":1},{}]"#).unwrap()).unwrap();
|
||||
assert_eq!(
|
||||
response,
|
||||
json!([{"jsonrpc":"2.0","id":[1],"result":{}},{"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"missing `method`"}}])
|
||||
);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user