Paper scene: a sheet as a vector PDF, geometry only (#4890 P1)

A new writer, io::paper::paper_pdf, beside paper_svg and paper_png, reading
the same walk: one page the sheet's size, its lines, arcs, cubics, parabolas,
fills and dashes. Text follows with P2.

- The file comes from pdf-writer 0.15 (MIT OR Apache-2.0; brings ryu): a
  catalog, one page whose MediaBox is the sheet in points, the content
  deflated with flate2 (already in the tree through zip), and an Info
  dictionary: Producer "SolidCraft <version>", the Title when one is given,
  and CreationDate/ModDate only from PdfOptions::output_time (UTC), never the
  clock, so a scene always gives the same bytes. ISO 32000-1 14.3.3: unknown
  entries are left out, not written empty.
- Numbers: the walk runs on a 10 nm grid (Grid::TEN_NANOMETRES), written as
  millimetres with up to five decimals (Annex C's precision) inside one
  `2.834645669 0 0 2.834645669 0 0 cm`; y is up in both, so nothing flips. The
  SVG writer's number rule moves to io::paper::push_mm, taking the decimals.
- Arcs: each of the walk's quarter-turn pieces is cut into as many 4/3 tan(t/4)
  cubics as keep it within 1e-4 mm, the rounding of control points onto the
  grid included (one cubic a quarter turn would be 2.7e-4 r off). The arc's
  centre comes from Piece::seg, the rule the flattener used, moved onto Piece
  so both read it. Parabolas are raised to cubics.
- Paint: w at the walked width (never 0: 8.4.3.2 says 0 is a device pixel),
  0 J 0 j 4 M as SVG and PNG, d for A5's dashes, each set only when it changes;
  closed outlines `s`, fills even-odd `f*`.
- Refused: a page under 3 pt a side (Annex C), a title over 1,000 characters,
  a date past 9999.
- Dates use io::civil, the crash reports' rule (moved in the commit below).

Tests: the A3 MediaBox; 50 mm on paper is 141.732 pt; the same bytes twice,
dates only from output_time (2000-02-29 and 9999-12-31 23:59:59); every xref
entry at its object; arcs from 0.5 mm to 2 m radius within 1e-4 mm and a
parabola on its cubic, every number at most five decimals; widths, dashes,
closes and fills as the other writers paint them; the refusals. One fuzz scene
now feeds the SVG, PNG and PDF mutation tests.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Cameron WightandClaude Opus 5.5 committed 2026-10-27 10:24:01 +00:00
1 parent 884fc53700
commit 7dc82dc7bb
10 files changed
+588 -74

No files matched your search

Generated
+20
View File
@@ -3070,6 +3070,18 @@ dependencies = [
"windows-link",
]
[[package]]
name = "pdf-writer"
version = "0.15.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f5e456864a7a304047bff84977dc6fb162bd956475d40ba50b2dcecaada7f753"
dependencies = [
"bitflags 2.13.2",
"itoa",
"memchr",
"ryu",
]
[[package]]
name = "peniko"
version = "0.6.1"
@@ -3749,6 +3761,12 @@ version = "1.0.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
[[package]]
name = "ryu"
version = "1.0.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"
[[package]]
name = "same-file"
version = "1.0.6"
@@ -4287,8 +4305,10 @@ dependencies = [
"cadmpeg-registry",
"chardetng",
"encoding_rs",
"flate2",
"gltf",
"log",
"pdf-writer",
"png",
"quick-xml",
"rustix 1.1.5",
+4
View File
@@ -83,6 +83,10 @@ image = { version = "0.25", default-features = false, features = ["png", "hdr"]
png = "0.18.1"
# LZW for GIF animations (MIT OR Apache-2.0, pure Rust; already in the tree through image's tiff).
weezl = "0.1.12"
# sheet PDFs (MIT OR Apache-2.0, pure Rust; brings ryu, Apache-2.0 OR BSL-1.0)
pdf-writer = "0.15"
# deflate for PDF content streams (MIT OR Apache-2.0; already in the tree through zip)
flate2 = "1.1"
# rasterises the UI icon SVGs (BSD-3-Clause, pure Rust, builds for wasm)
tiny-skia = { version = "0.12", default-features = false, features = ["std", "simd"] }
# build scripts: reads the icon palette (MIT OR Apache-2.0)
+9 -29
View File
@@ -6,11 +6,10 @@
//! Each piece becomes the [`Seg2`] it is and takes [`Seg2::chords`]' steps, the bound
//! [`Seg2::polyline`] uses too. `polyline` itself doesn't fit here: it floors an arc's tolerance at
//! a millionth of its radius and caps a piece at 4096 steps, both coarser than asked, without a
//! word. An arc comes from the walk as its ends, radius and direction, which fix its centre (well
//! conditioned up to the walk's quarter turns).
//! word. Each piece is the curve [`Piece::seg`](super::Piece::seg) says.
use super::{GridPath, GridPoint, Invalid, Piece, Result};
use crate::{Seg2, Vec2};
use super::{GridPath, Invalid, Result};
use crate::Vec2;
/// The most points one path may flatten to.
pub const MAX_POINTS: usize = 1 << 20;
@@ -21,37 +20,18 @@ pub fn flatten(path: &GridPath, tolerance: f64) -> Result<Vec<Vec2>> {
if !(tolerance > 0.0 && tolerance.is_finite()) {
return Err(Invalid("a flattening tolerance is above 0"));
}
let mut points = vec![v(path.start)];
let mut at = v(path.start);
let mut points = vec![path.start.vec()];
let mut at = path.start;
for piece in &path.pieces {
let to = v(piece.to());
let seg = match *piece {
Piece::Line { .. } => Seg2::Line { a: at, b: to },
Piece::Arc { radius, clockwise, .. } => {
let r = radius as f64;
let half = at.dist(to) / 2.0;
// The centre sits off the chord's middle, left of it for an anticlockwise turn.
let off = (r * r - half * half).max(0.0).sqrt();
let side = (to - at).normalized().map_or(Vec2::new(0.0, 0.0), Vec2::perp);
let center = (at + to) / 2.0 + side * if clockwise { -off } else { off };
let sweep = 2.0 * (half / r).min(1.0).asin() * if clockwise { -1.0 } else { 1.0 };
Seg2::Arc { center, radius: r, start: (at - center).angle(), sweep }
}
Piece::Cubic { c1, c2, .. } => Seg2::Cubic { p0: at, p1: v(c1), p2: v(c2), p3: to },
Piece::Quadratic { c, .. } => Seg2::Conic { a: at, apex: v(c), b: to, w: 1.0 },
};
let seg = piece.seg(at);
let n = steps(seg.chords(tolerance), points.len())?;
points.extend((1..n).map(|i| seg.point_at(i as f64 / n as f64)));
points.push(to);
at = to;
points.push(piece.to().vec());
at = piece.to();
}
Ok(points)
}
fn v(p: GridPoint) -> Vec2 {
Vec2::new(p.x as f64, p.y as f64)
}
/// `bound` rounded up to whole steps, at least one, refused when a path that has `so_far` points
/// would go over [`MAX_POINTS`].
fn steps(bound: f64, so_far: usize) -> Result<usize> {
@@ -136,7 +116,7 @@ mod tests {
let quarter = on_grid(Seg2::Arc { center: p(50.0, 50.0), radius: 10.0, start: 0.0, sweep: FRAC_PI_2 });
let points = flatten(&quarter, 1e3).unwrap();
assert_eq!(points.len(), 57);
assert_eq!(points.last().copied(), Some(v(quarter.pieces[0].to())));
assert_eq!(points.last().copied(), Some(quarter.pieces[0].to().vec()));
// A cubic whose largest second difference is √1700 ≈ 41.2 mm, within 1 µm: √(0.75 · 4.12e7 / 1e3) → 176.
let cubic = on_grid(Seg2::Cubic { p0: p(0.0, 0.0), p1: p(10.0, 40.0), p2: p(30.0, 40.0), p3: p(40.0, 0.0) });
assert_eq!(flatten(&cubic, 1e3).unwrap().len(), 1 + 176);
+30
View File
@@ -29,6 +29,8 @@ pub struct Grid {
impl Grid {
/// Whole nanometres, six decimals of a millimetre: SVG's numbers.
pub const NANOMETRE: Grid = Grid { per_mm: 1e6 };
/// Steps of 10 nm, five decimals of a millimetre: PDF's numbers (ISO 32000-1 Annex C's precision).
pub const TEN_NANOMETRES: Grid = Grid { per_mm: 1e5 };
/// A grid of `per_mm` steps a millimetre, from 1 to 1e9. A power of two keeps every number
/// exact in binary floating point, as a writer of 32-bit numbers (PDF) wants.
@@ -89,6 +91,34 @@ impl Piece {
Piece::Line { to } | Piece::Arc { to, .. } | Piece::Cubic { to, .. } | Piece::Quadratic { to, .. } => to,
}
}
/// The curve this piece is, from `from`, in steps. An arc's ends, radius and direction fix its
/// centre, well conditioned up to the walk's quarter turns.
pub fn seg(&self, from: GridPoint) -> Seg2 {
let (at, to) = (from.vec(), self.to().vec());
match *self {
Piece::Line { .. } => Seg2::Line { a: at, b: to },
Piece::Arc { radius, clockwise, .. } => {
let r = radius as f64;
let half = at.dist(to) / 2.0;
// The centre sits off the chord's middle, left of it for an anticlockwise turn.
let off = (r * r - half * half).max(0.0).sqrt();
let side = (to - at).normalized().map_or(Vec2::new(0.0, 0.0), Vec2::perp);
let center = (at + to) / 2.0 + side * if clockwise { -off } else { off };
let sweep = 2.0 * (half / r).min(1.0).asin() * if clockwise { -1.0 } else { 1.0 };
Seg2::Arc { center, radius: r, start: (at - center).angle(), sweep }
}
Piece::Cubic { c1, c2, .. } => Seg2::Cubic { p0: at, p1: c1.vec(), p2: c2.vec(), p3: to },
Piece::Quadratic { c, .. } => Seg2::Conic { a: at, apex: c.vec(), b: to, w: 1.0 },
}
}
}
impl GridPoint {
/// The point in steps, as a [`Vec2`].
pub fn vec(self) -> Vec2 {
Vec2::new(self.x as f64, self.y as f64)
}
}
/// A path on the grid: its pieces from `start`. A closed one ends on `start`, its closing line
+3
View File
@@ -25,6 +25,9 @@ encoding_rs = { workspace = true }
# Sheet PNGs (src/paper/png.rs).
png = { workspace = true }
tiny-skia = { workspace = true }
# Sheet PDFs (src/paper/pdf.rs).
pdf-writer = { workspace = true }
flate2 = { workspace = true }
# A plain fsync where a network share refuses Apple's full flush (src/safe_write.rs); already in
# the tree through tempfile.
+34 -33
View File
@@ -550,68 +550,69 @@ outer
});
}
/// A paper scene's JSON, mutated, read, prepared and written as SVG: an error or a document,
/// never a panic.
#[test]
fn paper_scenes_survive_mutation_into_svg() {
/// An A3 paper scene's JSON for the writers' mutation tests: a closed border, a dashed arc, and
/// a fill with a hole.
fn paper_scene_json() -> Vec<u8> {
use solidcraft_geom::paper::{Dashes, Group, Item, ObjectKind, Scene};
use solidcraft_geom::{Loop2, Region2, Seg2, Vec2};
let p = Vec2::new;
let border = Loop2::polygon(&[p(20.0, 10.0), p(410.0, 10.0), p(410.0, 287.0), p(20.0, 287.0)]);
let dashes = || Dashes { lengths_mm: vec![4.2, 1.05, 0.5, 1.05], phase_mm: 0.5 };
let dashes = Dashes { lengths_mm: vec![4.2, 1.05, 0.5, 1.05], phase_mm: 0.5 };
let items = vec![
Item::Stroke { path: border.segs.clone(), closed: true, width_mm: 0.7, pattern: None },
Item::Stroke {
path: vec![Seg2::Arc { center: p(50.0, 50.0), radius: 10.0, start: 0.0, sweep: 4.0 }],
closed: false,
width_mm: 0.35,
pattern: Some(dashes()),
pattern: Some(dashes),
},
Item::Fill { region: Region2 { outer: border, holes: vec![] } },
Item::Fill { region: Region2 { outer: border, holes: vec![Loop2::circle(p(100.0, 100.0), 20.0)] } },
];
let scene = Scene { size_mm: p(420.0, 297.0), groups: vec![Group { object: 7, kind: ObjectKind::DrawingBorder, items }] };
let json = serde_json::to_vec(&scene).unwrap();
serde_json::to_vec(&scene).unwrap()
}
/// A paper scene's JSON, mutated, read, prepared and written as SVG: an error or a document,
/// never a panic.
#[test]
fn paper_scenes_survive_mutation_into_svg() {
let json = paper_scene_json();
let write = |b: &[u8]| -> Option<usize> {
let scene: Scene = serde_json::from_slice(b).ok()?;
let prepared = scene.prepare().ok()?;
crate::paper::paper_svg(&prepared).ok().map(|(bytes, _)| bytes.len())
let scene: solidcraft_geom::paper::Scene = serde_json::from_slice(b).ok()?;
crate::paper::paper_svg(&scene.prepare().ok()?).ok().map(|(bytes, _)| bytes.len())
};
assert!(write(&json).is_some());
survives("paper scene to SVG", &mutations(&json, true, 0x5a3), usize::MAX, write);
}
/// The same scene's JSON, mutated, read, prepared and written as a 25 dpi sheet PNG: an error or
/// an image, never a panic.
/// The same scene written as a 25 dpi sheet PNG: an error or an image, never a panic.
#[test]
fn paper_scenes_survive_mutation_into_png() {
use solidcraft_geom::paper::{Dashes, Group, Item, ObjectKind, Scene};
use solidcraft_geom::{Loop2, Region2, Seg2, Vec2};
let p = Vec2::new;
let border = Loop2::polygon(&[p(20.0, 10.0), p(410.0, 10.0), p(410.0, 287.0), p(20.0, 287.0)]);
let dashes = || Dashes { lengths_mm: vec![4.2, 1.05, 0.5, 1.05], phase_mm: 0.5 };
let items = vec![
Item::Stroke { path: border.segs.clone(), closed: true, width_mm: 0.7, pattern: None },
Item::Stroke {
path: vec![Seg2::Arc { center: p(50.0, 50.0), radius: 10.0, start: 0.0, sweep: 4.0 }],
closed: false,
width_mm: 0.35,
pattern: Some(dashes()),
},
Item::Fill { region: Region2 { outer: border, holes: vec![Loop2::circle(p(100.0, 100.0), 20.0)] } },
];
let scene = Scene { size_mm: p(420.0, 297.0), groups: vec![Group { object: 7, kind: ObjectKind::DrawingBorder, items }] };
let json = serde_json::to_vec(&scene).unwrap();
let json = paper_scene_json();
let options = crate::paper::PngOptions { dpi: 25.0, colour: crate::paper::PngColour::Grey };
let write = |b: &[u8]| -> Option<usize> {
let scene: Scene = serde_json::from_slice(b).ok()?;
let prepared = scene.prepare().ok()?;
let scene: solidcraft_geom::paper::Scene = serde_json::from_slice(b).ok()?;
let mut out = Vec::new();
crate::paper::paper_png(&prepared, options, &mut out).ok().map(|_| out.len())
crate::paper::paper_png(&scene.prepare().ok()?, options, &mut out).ok().map(|_| out.len())
};
assert!(write(&json).is_some());
survives("paper scene to PNG", &mutations(&json, true, 0x5a4), usize::MAX, write);
}
/// The same scene written as a PDF with a title and a date: an error or a document, never a
/// panic.
#[test]
fn paper_scenes_survive_mutation_into_pdf() {
let json = paper_scene_json();
let options = crate::paper::PdfOptions { title: Some("Sheet 1".into()), output_time: Some(1_761_436_800) };
let write = |b: &[u8]| -> Option<usize> {
let scene: solidcraft_geom::paper::Scene = serde_json::from_slice(b).ok()?;
crate::paper::paper_pdf(&scene.prepare().ok()?, &options).ok().map(|(bytes, _)| bytes.len())
};
assert!(write(&json).is_some());
survives("paper scene to PDF", &mutations(&json, true, 0x5a5), usize::MAX, write);
}
/// Standard base64 (RFC 4648) of `bytes`, for a data URI.
fn base64(bytes: &[u8]) -> String {
const A: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+22 -1
View File
@@ -1,7 +1,28 @@
//! A sheet's paper scene (`geom::paper`) in a file: SVG (A3, #4890) and sheet PNG (A4); DXF and PDF follow.
//! A sheet's paper scene (`geom::paper`) in a file: SVG (A3, #4890), sheet PNG (A4) and PDF (P1);
//! DXF follows.
use std::fmt::Write;
mod pdf;
mod png;
mod svg;
pub use pdf::{PdfOptions, PdfReport, paper_pdf};
pub use png::{DPI, MAX_POINTS, PngColour, PngOptions, PngReport, paper_png};
pub use svg::{SvgReport, paper_svg};
/// Grid steps written as millimetres onto `out`, on a grid of 10^`decimals` steps a millimetre:
/// the integer part, then up to `decimals` decimals without trailing zeros. No exponent, no "-0",
/// nothing that depends on the locale.
fn push_mm(out: &mut String, n: i64, decimals: u32) {
let unit = 10_u64.pow(decimals);
let (sign, n) = if n < 0 { ("-", n.unsigned_abs()) } else { ("", n.unsigned_abs()) };
let (whole, mut part, mut digits) = (n / unit, n % unit, decimals as usize);
let _ = write!(out, "{sign}{whole}");
if part != 0 {
while part % 10 == 0 {
(part, digits) = (part / 10, digits - 1);
}
let _ = write!(out, ".{part:0digits$}");
}
}
+260
View File
@@ -0,0 +1,260 @@
//! A paper scene as a vector PDF (#4890, P1): one page the sheet's size, its lines and fills,
//! geometry only (text follows with P2).
//!
//! - **The file** comes from `pdf-writer`: a catalog, one page whose MediaBox is the sheet in
//! points, its content deflated, and an Info dictionary with the Producer, the Title when there
//! is one (ISO 32000-1 14.3.3: leave out what isn't known) and dates only from
//! [`PdfOptions::output_time`], never the clock, so a scene always gives the same bytes.
//! - **Numbers** are the scene on a 10 nm grid ([`Grid::TEN_NANOMETRES`], whose walk gives the
//! joints, closures and merges SVG and PNG draw), written as millimetres with up to five
//! decimals (Annex C's precision) inside one `cm` that scales millimetres to points. y is up on
//! the page as in the scene, so nothing flips.
//! - **Curves:** lines `l` and cubics `c` as they are; a parabola raised to a cubic; an arc's
//! pieces (each at most a quarter turn) cut into cubics that stay within [`ARC_TOLERANCE_MM`],
//! their rounding onto the grid included.
//! - **Paint:** strokes at their width `w` (the walk never gives 0, which 8.4.3.2 says is a device
//! pixel and shouldn't be used), butt caps, miter joins and a miter limit of 4, dashed by `d`;
//! fills black, even-odd (`f*`). Black on no background, as SVG.
use std::f64::consts::FRAC_PI_2;
use std::fmt::Write as _;
use std::io::Write as _;
use flate2::Compression;
use flate2::write::ZlibEncoder;
use pdf_writer::{Date, Filter, Pdf, Rect, Ref, TextStr};
use solidcraft_geom::paper::{Grid, GridDashes, GridGroup, GridItem, GridPath, GridPoint, GridReport, Piece, Prepared};
use solidcraft_geom::{Seg2, Vec2};
use super::push_mm;
use crate::{IoError, MAX_DRAWING_BYTES, Result};
/// How far an arc's cubics may stray from the arc, rounding onto the grid included.
pub const ARC_TOLERANCE_MM: f64 = 1e-4;
/// Points a millimetre.
const PT_PER_MM: f64 = 72.0 / 25.4;
/// The smallest page side, in points (Annex C).
const MIN_PAGE_PT: f64 = 3.0;
/// The most characters a title may have.
const MAX_TITLE_CHARS: usize = 1000;
/// The last second a PDF date can hold: 9999-12-31 23:59:59 UTC.
const MAX_OUTPUT_TIME: u64 = 253_402_300_799;
/// Decimals of a millimetre on the grid.
const DECIMALS: u32 = 5;
/// What a sheet PDF says beyond the scene.
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct PdfOptions {
/// The document's title, left out when `None` or empty.
pub title: Option<String>,
/// When the PDF was made, in seconds since 1970 (UTC): its creation and modification dates.
/// Without it the file has no dates.
pub output_time: Option<u64>,
}
/// What writing a scene did that the scene didn't say: the grid's report.
pub type PdfReport = GridReport;
/// A scene's PDF document, and what writing it did.
pub fn paper_pdf(scene: &Prepared, options: &PdfOptions) -> Result<(Vec<u8>, PdfReport)> {
let title = options.title.as_deref().filter(|t| !t.is_empty());
if title.is_some_and(|t| t.chars().count() > MAX_TITLE_CHARS) {
return Err(IoError::Invalid(format!("a sheet PDF's title is at most {MAX_TITLE_CHARS} characters")));
}
let date = options.output_time.map(date).transpose()?;
let on = scene.on_grid(Grid::TEN_NANOMETRES).map_err(|e| IoError::Invalid(e.to_string()))?;
let page = [on.size.x, on.size.y].map(|n| n as f64 / Grid::TEN_NANOMETRES.per_mm() * PT_PER_MM);
if page.iter().any(|side| *side < MIN_PAGE_PT) {
return Err(IoError::Invalid(format!("a sheet PDF's page is at least {MIN_PAGE_PT} pt (about 1.06 mm) a side")));
}
let content = content(&on.groups)?;
let mut deflate = ZlibEncoder::new(Vec::new(), Compression::default());
let compressed = deflate.write_all(content.as_bytes()).and_then(|()| deflate.finish());
let compressed = compressed.map_err(|e| IoError::Invalid(format!("the sheet PDF: {e}")))?;
// Each object's number, used once (pdf-writer panics on a number written twice).
let (catalog, tree, page_id, contents, info) = (Ref::new(1), Ref::new(2), Ref::new(3), Ref::new(4), Ref::new(5));
let mut pdf = Pdf::new();
pdf.catalog(catalog).pages(tree);
pdf.pages(tree).kids([page_id]).count(1);
let mut writer = pdf.page(page_id);
writer.parent(tree).media_box(Rect::new(0.0, 0.0, page[0] as f32, page[1] as f32)).contents(contents);
writer.resources();
drop(writer);
pdf.stream(contents, &compressed).filter(Filter::FlateDecode);
let mut doc = pdf.document_info(info);
doc.producer(TextStr(concat!("SolidCraft ", env!("CARGO_PKG_VERSION"))));
if let Some(title) = title {
doc.title(TextStr(title));
}
if let Some(date) = date {
doc.creation_date(date).modified_date(date);
}
drop(doc);
Ok((pdf.finish(), on.report))
}
/// `secs` since 1970 as a PDF date in UTC, refused past the year 9999.
fn date(secs: u64) -> Result<Date> {
if secs > MAX_OUTPUT_TIME {
return Err(IoError::Invalid("a sheet PDF's date is at most the year 9999".into()));
}
let (year, month, day, hour, minute, second) = crate::civil(secs);
let (month, day) = (u8::try_from(month).unwrap_or(1), u8::try_from(day).unwrap_or(1));
let [hour, minute, second] = [hour, minute, second].map(|v| u8::try_from(v).unwrap_or(0));
Ok(Date::new(u16::try_from(year).unwrap_or(0)).month(month).day(day).hour(hour).minute(minute).second(second).utc_offset_hour(0))
}
/// The page's content stream: the scene in millimetres, scaled to points once.
fn content(groups: &[GridGroup]) -> Result<String> {
let mut w = Content { out: String::new(), width: None, dashes: None };
let _ = writeln!(w.out, "q {PT_PER_MM:.9} 0 0 {PT_PER_MM:.9} 0 0 cm 0 J 0 j 4 M");
for item in groups.iter().flat_map(|g| &g.items) {
match item {
GridItem::Stroke { width, path, dashes } => {
if w.width != Some(*width) {
w.number(*width);
w.out.push_str(" w\n");
w.width = Some(*width);
}
if w.dashes.as_ref() != dashes.as_ref() {
w.dashes(dashes.as_ref());
w.dashes.clone_from(dashes);
}
w.path(path)?;
// A closed path's closing line, then the stroke: `s`.
w.out.push_str(if path.closed { "s\n" } else { "S\n" });
}
GridItem::Fill { loops } => {
for l in loops {
w.path(l)?;
w.out.push_str("h\n");
}
w.out.push_str("f*\n");
}
}
if w.out.len() > MAX_DRAWING_BYTES {
return Err(IoError::Invalid(format!("the PDF's drawing would be over {} MiB", MAX_DRAWING_BYTES >> 20)));
}
}
w.out.push_str("Q\n");
Ok(w.out)
}
struct Content {
out: String,
/// The stroke width and dash pattern last set, so each is written only when it changes.
width: Option<i64>,
dashes: Option<GridDashes>,
}
impl Content {
fn number(&mut self, n: i64) {
push_mm(&mut self.out, n, DECIMALS);
}
fn point(&mut self, p: GridPoint) {
self.number(p.x);
self.out.push(' ');
self.number(p.y);
self.out.push(' ');
}
/// `p` in steps, rounded onto the grid.
fn near(&mut self, p: Vec2) -> Result<()> {
if !p.is_finite() {
return Err(IoError::Invalid("the sheet PDF: a curve point is not a number".into()));
}
self.point(GridPoint { x: p.x.round() as i64, y: p.y.round() as i64 });
Ok(())
}
/// A dash pattern `[on off …] phase d`, or a solid line `[] 0 d`.
fn dashes(&mut self, dashes: Option<&GridDashes>) {
self.out.push('[');
if let Some(d) = dashes {
for (i, length) in d.lengths.iter().enumerate() {
if i > 0 {
self.out.push(' ');
}
self.number(*length);
}
}
self.out.push_str("] ");
self.number(dashes.map_or(0, |d| d.phase));
self.out.push_str(" d\n");
}
/// A path from its start; a closed one's closing line is left to the caller's `h` or `s`.
fn path(&mut self, path: &GridPath) -> Result<()> {
self.point(path.start);
self.out.push_str("m\n");
let mut at = path.start;
for piece in &path.pieces {
match *piece {
Piece::Line { to } => {
self.point(to);
self.out.push_str("l\n");
}
Piece::Cubic { c1, c2, to } => {
self.point(c1);
self.point(c2);
self.point(to);
self.out.push_str("c\n");
}
// A parabola is the cubic with its control points two thirds of the way to `c`.
Piece::Quadratic { c, to } => {
let (a, c, b) = (at.vec(), c.vec(), to.vec());
self.near(a + (c - a) * (2.0 / 3.0))?;
self.near(b + (c - b) * (2.0 / 3.0))?;
self.point(to);
self.out.push_str("c\n");
}
Piece::Arc { .. } => self.arc(piece.seg(at), piece.to())?,
}
at = piece.to();
}
Ok(())
}
/// An arc piece as cubics within [`ARC_TOLERANCE_MM`], ending exactly on `to`.
fn arc(&mut self, arc: Seg2, to: GridPoint) -> Result<()> {
let Seg2::Arc { center, radius, start, sweep } = arc else {
return Err(IoError::Invalid("the sheet PDF: an arc piece isn't an arc".into()));
};
let n = cubics_for(radius, sweep).ok_or_else(|| IoError::Invalid("the sheet PDF: an arc needs too many cubics".into()))?;
let h = sweep / n as f64;
let k = 4.0 / 3.0 * (h / 4.0).tan() * radius;
let tangent = |a: f64| Vec2::new(-a.sin(), a.cos());
for i in 0..n {
let (a0, a1) = (start + h * i as f64, start + h * (i + 1) as f64);
let (p0, p3) = (center + Vec2::from_angle(a0) * radius, center + Vec2::from_angle(a1) * radius);
self.near(p0 + tangent(a0) * k)?;
self.near(p3 - tangent(a1) * k)?;
if i + 1 == n {
self.point(to)
} else {
self.near(p3)?
}
self.out.push_str("c\n");
}
Ok(())
}
}
/// How many equal cubics keep an arc of `radius` steps and `sweep` (at most a quarter turn) within
/// the tolerance. The 4/3·tan(θ/4) cubic of a θ arc strays at most r·(2/27)·sin⁶(θ/4)/cos²(θ/4)
/// from it, outward; each control point rounded onto the grid moves the curve at most half a
/// step's diagonal more.
fn cubics_for(radius: f64, sweep: f64) -> Option<usize> {
let tolerance = ARC_TOLERANCE_MM * Grid::TEN_NANOMETRES.per_mm() - std::f64::consts::FRAC_1_SQRT_2;
let strays = |theta: f64| radius * (2.0 / 27.0) * (theta / 4.0).sin().powi(6) / (theta / 4.0).cos().powi(2);
(sweep.is_finite() && sweep.abs() <= FRAC_PI_2 + 1e-9 && radius.is_finite())
.then(|| (1..=64).find(|&n| strays(sweep.abs() / n as f64) <= tolerance))
.flatten()
}
#[cfg(test)]
#[path = "pdf_tests.rs"]
mod tests;
+204
View File
@@ -0,0 +1,204 @@
use std::f64::consts::{FRAC_PI_2, TAU};
use std::io::Read;
use solidcraft_geom::paper::{Dashes, Group, Item, ObjectKind, Scene};
use solidcraft_geom::{Loop2, Region2, Seg2, Vec2};
use super::*;
fn p(x: f64, y: f64) -> Vec2 {
Vec2::new(x, y)
}
fn scene(size: Vec2, items: Vec<Item>) -> Scene {
Scene { size_mm: size, groups: vec![Group { object: 1, kind: ObjectKind::DrawingBorder, items }] }
}
fn stroke(path: Vec<Seg2>, closed: bool, width_mm: f64, pattern: Option<Dashes>) -> Item {
Item::Stroke { path, closed, width_mm, pattern }
}
fn pdf(scene: &Scene, options: &PdfOptions) -> Vec<u8> {
paper_pdf(&scene.prepare().unwrap(), options).unwrap().0
}
fn text(bytes: &[u8]) -> String {
String::from_utf8_lossy(bytes).into_owned()
}
/// The page's content stream, inflated.
fn content(bytes: &[u8]) -> String {
let at = bytes.windows(7).position(|w| w == b"stream\n").unwrap() + 7;
let end = at + bytes[at..].windows(10).position(|w| w == b"endstream\n" || w == b"\nendstream").unwrap();
let mut out = String::new();
flate2::read::ZlibDecoder::new(&bytes[at..end]).read_to_string(&mut out).unwrap();
out
}
/// The content's operators, each with its operands, numbers read as numbers.
fn ops(content: &str) -> Vec<(String, Vec<f64>)> {
let spaced = content.replace('[', " [ ").replace(']', " ] ");
let mut ops = Vec::new();
let mut operands = Vec::new();
for token in spaced.split_whitespace() {
match token.parse::<f64>() {
Ok(n) => operands.push(n),
Err(_) if token == "[" || token == "]" => {}
Err(_) => ops.push((token.to_string(), std::mem::take(&mut operands))),
}
}
ops
}
/// Each cubic in the content as its four points, in millimetres.
fn cubics(content: &str) -> Vec<[Vec2; 4]> {
let (mut at, mut out) = (p(0.0, 0.0), Vec::new());
for (op, n) in ops(content) {
match op.as_str() {
"m" | "l" => at = p(n[0], n[1]),
"c" => {
out.push([at, p(n[0], n[1]), p(n[2], n[3]), p(n[4], n[5])]);
at = p(n[4], n[5]);
}
_ => {}
}
}
out
}
fn bezier([p0, p1, p2, p3]: [Vec2; 4], t: f64) -> Vec2 {
let s = 1.0 - t;
p0 * (s * s * s) + p1 * (3.0 * s * s * t) + p2 * (3.0 * s * t * t) + p3 * (t * t * t)
}
const NONE: PdfOptions = PdfOptions { title: None, output_time: None };
/// An A3 sheet's page is A3 in points, and the PDF says who made it.
#[test]
fn an_a3_sheet_is_its_size_in_points() {
let bytes = pdf(&scene(p(420.0, 297.0), vec![]), &NONE);
let file = text(&bytes);
assert!(file.starts_with("%PDF-"), "{}", &file[..20]);
assert!(file.contains("/MediaBox [0 0 1190.5511 841.8898]"), "{file}");
assert!(file.contains(&format!("/Producer (SolidCraft {})", env!("CARGO_PKG_VERSION"))), "{file}");
assert!(!file.contains("/Title"), "no title asked for: {file}");
}
/// A 100 mm edge at 1:2 is a 50 mm line on paper: 141.732 pt across the page.
#[test]
fn fifty_millimetres_on_paper_are_141_732_points() {
let line = scene(p(210.0, 297.0), vec![stroke(vec![Seg2::Line { a: p(10.0, 20.0), b: p(60.0, 20.0) }], false, 0.5, None)]);
let ops = ops(&content(&pdf(&line, &NONE)));
let cm = ops.iter().find(|(op, _)| op == "cm").unwrap();
assert_eq!(cm.1[..4], [cm.1[0], 0.0, 0.0, cm.1[0]], "one scale, millimetres to points");
let ends: Vec<f64> = ops.iter().filter(|(op, _)| op == "m" || op == "l").map(|(_, n)| n[0]).collect();
assert_eq!(ends, [10.0, 60.0]);
assert!(((ends[1] - ends[0]) * cm.1[0] - 141.732).abs() < 1e-3, "{}", (ends[1] - ends[0]) * cm.1[0]);
}
/// The same scene gives the same bytes; the dates come only from `output_time`, in UTC.
#[test]
fn the_same_scene_gives_the_same_bytes_and_dates_come_only_from_output_time() {
let sheet = scene(p(210.0, 297.0), vec![stroke(vec![Seg2::Line { a: p(10.0, 20.0), b: p(60.0, 20.0) }], false, 0.5, None)]);
assert_eq!(pdf(&sheet, &NONE), pdf(&sheet, &NONE));
assert!(!text(&pdf(&sheet, &NONE)).contains("Date"));
let leap_day = PdfOptions { title: Some("Sheet 1".into()), output_time: Some(951_782_400) };
let file = text(&pdf(&sheet, &leap_day));
assert!(file.contains("/CreationDate (D:20000229000000Z)") && file.contains("/ModDate (D:20000229000000Z)"), "{file}");
assert!(file.contains("/Title (Sheet 1)"), "{file}");
assert_eq!(pdf(&sheet, &leap_day), pdf(&sheet, &leap_day));
let last = PdfOptions { title: Some(String::new()), output_time: Some(MAX_OUTPUT_TIME) };
let file = text(&pdf(&sheet, &last));
assert!(file.contains("(D:99991231235959Z)") && !file.contains("/Title"), "{file}");
}
/// The trailer's `startxref` points at the table, and each entry at its `N 0 obj`.
#[test]
fn every_cross_reference_points_at_its_object() {
let sheet = scene(p(420.0, 297.0), vec![stroke(Loop2::circle(p(100.0, 100.0), 40.0).segs, true, 0.7, None)]);
let bytes = pdf(&sheet, &PdfOptions { title: Some("Ç".into()), output_time: Some(0) });
let file = text(&bytes);
let start: usize = file.rsplit("startxref").next().unwrap().split_whitespace().next().unwrap().parse().unwrap();
assert!(file[start..].starts_with("xref\n0 6\n"), "{}", &file[start..start + 20]);
let entries = &file[start + "xref\n0 6\n".len()..];
for (n, entry) in entries.as_bytes().chunks(20).take(6).enumerate().skip(1) {
let entry = std::str::from_utf8(entry).unwrap();
let offset: usize = entry[..10].parse().unwrap();
assert!(entry[10..].starts_with(" 00000 n"), "{entry:?}");
assert!(file[offset..].starts_with(&format!("{n} 0 obj")), "object {n} at {offset}");
}
}
/// Arcs are cubics within a ten-thousandth of a millimetre, from a 0.5 mm radius to 2 m, and a
/// parabola is its cubic; every number has at most five decimals.
#[test]
fn arcs_are_cubics_within_a_ten_thousandth_of_a_millimetre() {
for (radius, sweep) in [(0.5, TAU), (40.0, TAU), (300.0, 2.5), (2000.0, 0.3)] {
let c = p(2500.0, 2500.0);
let arc = scene(p(5000.0, 5000.0), vec![stroke(vec![Seg2::Arc { center: c, radius, start: 0.4, sweep }], false, 0.35, None)]);
let content = content(&pdf(&arc, &NONE));
let cubics = cubics(&content);
assert!(cubics.len() >= (sweep / FRAC_PI_2).ceil() as usize, "{radius}: {}", cubics.len());
for cubic in &cubics {
for k in 0..=64 {
let off = (bezier(*cubic, f64::from(k) / 64.0).dist(c) - radius).abs();
assert!(off <= ARC_TOLERANCE_MM, "r {radius}: {off} mm off at {k}/64");
}
}
assert!(content.split_whitespace().all(|t| t.split('.').nth(1).is_none_or(|d| d.len() <= 5)), "{content}");
}
let parabola = scene(
p(100.0, 100.0),
vec![stroke(vec![Seg2::Conic { a: p(10.0, 10.0), apex: p(30.0, 50.0), b: p(50.0, 10.0), w: 1.0 }], false, 0.35, None)],
);
let cubic = cubics(&content(&pdf(&parabola, &NONE)))[0];
for k in 0..=16 {
let t = f64::from(k) / 16.0;
let s = 1.0 - t;
let on = p(10.0, 10.0) * (s * s) + p(30.0, 50.0) * (2.0 * s * t) + p(50.0, 10.0) * (t * t);
assert!(bezier(cubic, t).dist(on) <= 1e-5, "{t}");
}
}
/// Strokes and fills are painted as SVG and PNG paint them: butt caps, miter joins, a miter limit
/// of 4, each width and dash pattern set once until it changes, a closed outline closed, fills
/// even-odd.
#[test]
fn strokes_and_fills_are_painted_as_the_other_writers_paint_them() {
let dashed = Some(Dashes { lengths_mm: vec![4.2, 1.05], phase_mm: 0.5 });
let line = |y: f64| vec![Seg2::Line { a: p(10.0, y), b: p(100.0, y) }];
let sheet = scene(
p(210.0, 297.0),
vec![
stroke(line(10.0), false, 0.35, None),
stroke(line(20.0), false, 0.35, dashed.clone()),
stroke(line(30.0), false, 0.35, dashed),
stroke(line(40.0), false, 0.7, None),
stroke(Loop2::polygon(&[p(10.0, 50.0), p(50.0, 50.0), p(50.0, 90.0)]).segs, true, 0.7, None),
Item::Fill { region: Region2 { outer: Loop2::circle(p(150.0, 150.0), 20.0), holes: vec![Loop2::circle(p(150.0, 150.0), 10.0)] } },
],
);
let content = content(&pdf(&sheet, &NONE));
assert!(content.starts_with("q 2.834645669 0 0 2.834645669 0 0 cm 0 J 0 j 4 M\n") && content.ends_with("Q\n"), "{content}");
let ops = ops(&content);
let set: Vec<(&str, &[f64])> = ops.iter().filter(|(op, _)| op == "w" || op == "d").map(|(op, n)| (op.as_str(), n.as_slice())).collect();
assert_eq!(set, [("w", &[0.35][..]), ("d", &[4.2, 1.05, 0.5][..]), ("w", &[0.7][..]), ("d", &[0.0][..])], "{content}");
let paints: Vec<&str> = ops.iter().map(|(op, _)| op.as_str()).filter(|op| ["S", "s", "f*", "h"].contains(op)).collect();
assert_eq!(paints, ["S", "S", "S", "S", "s", "h", "h", "f*"], "{content}");
}
/// A page under 3 pt a side, a title over 1,000 characters and a date past the year 9999 are
/// refused.
#[test]
fn what_cannot_be_written_is_refused() {
let tiny = scene(p(1.0, 297.0), vec![]);
let e = paper_pdf(&tiny.prepare().unwrap(), &NONE).unwrap_err();
assert!(e.to_string().contains("at least 3 pt"), "{e}");
let sheet = scene(p(210.0, 297.0), vec![]);
let prepared = sheet.prepare().unwrap();
assert!(paper_pdf(&prepared, &PdfOptions { title: Some("x".repeat(1000)), output_time: None }).is_ok());
let e = paper_pdf(&prepared, &PdfOptions { title: Some("x".repeat(1001)), output_time: None }).unwrap_err();
assert!(e.to_string().contains("1000 characters"), "{e}");
let e = paper_pdf(&prepared, &PdfOptions { title: None, output_time: Some(MAX_OUTPUT_TIME + 1) }).unwrap_err();
assert!(e.to_string().contains("9999"), "{e}");
}
+2 -11
View File
@@ -66,18 +66,9 @@ pub fn paper_svg(scene: &Prepared) -> Result<(Vec<u8>, SvgReport)> {
Ok((w.out.into_bytes(), on.report))
}
/// Nanometres written as millimetres onto `out`: the integer part, then up to six decimals
/// without trailing zeros.
/// Nanometres written as millimetres onto `out`, with up to six decimals.
fn push_number(out: &mut String, n: i64) {
let (sign, n) = if n < 0 { ("-", n.unsigned_abs()) } else { ("", n.unsigned_abs()) };
let (whole, mut part, mut digits) = (n / 1_000_000, n % 1_000_000, 6);
let _ = write!(out, "{sign}{whole}");
if part != 0 {
while part % 10 == 0 {
(part, digits) = (part / 10, digits - 1);
}
let _ = write!(out, ".{part:0digits$}");
}
super::push_mm(out, n, 6);
}
/// [`push_number`] as its own text, for the numbers written once per document.