fix(anatomy): V1-2.2 refuse annotations outside their view's frame

A view without view_box was framed by the drawing's viewBox: moving it and
translating the drawing back left the horse identical and its 19 main-view
markers out of frame, accepted. One frame definition (view_box, else the
drawing viewBox read with the SVG grammar) now frames both composers and is
measured by the verdict (verification.validation.out_of_frame) and the
preview; curves and arcs on their shape. The document is never rewritten.
This commit is contained in:
bchanot committed 2026-10-30 20:54:46 +01:00
1 parent 958228a9de
commit 0c87c7f6c3
8 files changed
+1406 -25

No files matched your search

+17 -7
View File
@@ -15,10 +15,17 @@
//! composers refuse such a tree.
//! Both forms append the marker layer as the root's last child, so the root never hides it: a
//! root `visibility` other than `visible` is refused by the reader and by both composers.
//! Both frame the view on `frame::view_frame` (the view's box, else the drawing's `viewBox` read
//! as a browser reads it), the frame the verdict and the preview measure the annotations against
//! (V1-2.2 owner brief 2026-10-30, defect 3); the canvas falls back to `0 0 100 100`, the PDF
//! view to no `viewBox`. The drawing's `preserveAspectRatio` is dropped: the default
//! `xMidYMid meet` shows the whole frame whatever the box (a `slice` would crop it where the
//! raster's aspect is clamped or the canvas box is not the frame's).
use std::collections::HashSet;
use super::layer::{LayerError, find_view, render_layer, view_box_of};
use super::frame::view_frame;
use super::layer::{LayerError, find_view, render_layer};
pub use super::svg::refs::HALO_FILTER_ID;
use super::svg::refs::holds_reserved_id;
use super::svg::sanitize::check_root_visibility;
@@ -97,14 +104,15 @@ pub fn compose_canvas(
attrs: asset
.attrs
.iter()
.filter(|a| a.qname != "width" && a.qname != "height")
.filter(|a| !matches!(a.qname.as_str(), "width" | "height" | "preserveAspectRatio"))
.cloned()
.collect(),
children: asset.children.clone(),
};
let view_box = view_box_of(view)
.or_else(|| asset.attr("viewBox").map(str::to_owned))
.unwrap_or_else(|| CANVAS_FALLBACK_VIEW_BOX.to_owned());
let view_box = view_frame(view, asset).map_or_else(
|| CANVAS_FALLBACK_VIEW_BOX.to_owned(),
|frame| frame.view_box(),
);
root.set_attr("viewBox", view_box);
let scope = id_scope(view_id);
scope_ids(&mut root, &scope);
@@ -183,11 +191,13 @@ pub fn compose_highlight(
if check_root_visibility(&asset).is_err() {
return Err(ComposeError::RootVisibility);
}
if let Some(view_box) = view_box_of(view) {
asset.set_attr("viewBox", view_box);
match view_frame(view, &asset) {
Some(frame) => asset.set_attr("viewBox", frame.view_box()),
None => asset.remove_attr("viewBox"),
}
asset.remove_attr("width");
asset.remove_attr("height");
asset.remove_attr("preserveAspectRatio");
if halo {
add_halo_filter(&mut asset);
}
+180
View File
@@ -0,0 +1,180 @@
//! The visible frame of a view, and whether an annotation lies in it (V1-2.2 owner brief
//! 2026-10-30, defect 3). One definition for the two composers, the server verdict and the
//! preview: the view's `view_box`, else the `viewBox` of the drawing the view draws, read with
//! the SVG grammar (`path::number_list`, four finite numbers, positive width and height).
//!
//! Annotations are drawn in the user space of the composition root, whose `viewBox` is that
//! frame and which carries no `preserveAspectRatio` (`xMidYMid meet`): the whole frame is
//! visible in the canvas and in the PDF raster, whatever their aspect. Transforms inside the
//! drawing move the drawing only; the reader removes the root's own `transform`. So an
//! annotation is in frame when every point of its shape is inside the frame, edges included.
use super::layer::find_view;
use super::path::{Bounds, number_list, path_bounds};
use super::svg::Element;
use crate::domain::sheet::{AnatomicalSheetDocument, Annotation, Geometry, SheetView};
use crate::json::js_number;
/// The rectangle of user space a view shows.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Frame {
pub min_x: f64,
pub min_y: f64,
pub width: f64,
pub height: f64,
}
/// Rounding slack on the edges, relative to the frame's span: far below a device pixel.
const EDGE_TOLERANCE: f64 = 1e-9;
impl Frame {
fn from_numbers(min_x: f64, min_y: f64, width: f64, height: f64) -> Option<Self> {
let usable = [min_x, min_y, width, height].iter().all(|n| n.is_finite())
&& width > 0.0
&& height > 0.0;
usable.then_some(Self {
min_x,
min_y,
width,
height,
})
}
/// The `viewBox` value the composers write, JavaScript number printing.
pub fn view_box(&self) -> String {
format!(
"{} {} {} {}",
js_number(self.min_x),
js_number(self.min_y),
js_number(self.width),
js_number(self.height)
)
}
fn holds(&self, bounds: &Bounds) -> bool {
let slack =
EDGE_TOLERANCE * (self.width.max(self.height) + self.min_x.abs().max(self.min_y.abs()));
bounds.min_x >= self.min_x - slack
&& bounds.min_y >= self.min_y - slack
&& bounds.max_x <= self.min_x + self.width + slack
&& bounds.max_y <= self.min_y + self.height + slack
}
}
/// The frame of `view` drawn on `drawing` (its sanitised root): the view's `view_box`, else
/// the drawing's `viewBox`; `None` when neither is usable.
pub fn view_frame(view: &SheetView, drawing: &Element) -> Option<Frame> {
match view.view_box() {
Some(b) => Frame::from_numbers(b.min_x, b.min_y, b.width, b.height),
None => drawing_frame(drawing),
}
}
/// The drawing root's `viewBox`, as a browser reads it.
pub fn drawing_frame(root: &Element) -> Option<Frame> {
match number_list(root.attr("viewBox")?)?.as_slice() {
[min_x, min_y, width, height] => Frame::from_numbers(*min_x, *min_y, *width, *height),
_ => None,
}
}
/// Where an annotation's shape lies against its view's frame.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Placement {
InFrame,
OutOfFrame,
/// Path data a browser would not read whole.
Unreadable,
}
pub fn geometry_bounds(geometry: &Geometry) -> Option<Bounds> {
match geometry {
Geometry::Circle(c) => Some(Bounds {
min_x: c.cx - c.r,
min_y: c.cy - c.r,
max_x: c.cx + c.r,
max_y: c.cy + c.r,
}),
Geometry::Polygon(p) => {
let (first, rest) = p.points.split_first()?;
let mut bounds = Bounds::point(first.0, first.1);
for point in rest {
bounds.add(point.0, point.1);
}
Some(bounds)
}
Geometry::Path(path) => path_bounds(&path.d),
}
}
pub fn placement(geometry: &Geometry, frame: &Frame) -> Placement {
match geometry_bounds(geometry) {
None => Placement::Unreadable,
Some(bounds) if frame.holds(&bounds) => Placement::InFrame,
Some(_) => Placement::OutOfFrame,
}
}
/// What the frame check found on one view.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum FrameFault {
/// The view has no usable frame (no `view_box`, no usable drawing `viewBox`).
NoFrame { view_index: usize },
/// An annotation of the view is not entirely inside it, or cannot be measured.
Annotation {
annotation_index: usize,
placement: Placement,
},
}
/// The frame faults of every view whose drawing `drawing_of` gives (by asset id); a view whose
/// drawing is missing or refused is not measured (its own failure names it).
pub fn frame_faults<'a>(
document: &AnatomicalSheetDocument,
drawing_of: impl Fn(&str) -> Option<&'a Element>,
) -> Vec<FrameFault> {
let mut faults = Vec::new();
for (view_index, view) in document.views.iter().enumerate() {
// A repeated view id draws the first view of that id, as the composers find it.
if !find_view(document, view.id()).is_some_and(|first| std::ptr::eq(first, view)) {
continue;
}
let drawing = super::compose::asset_id_of_view(document, view.id()).and_then(&drawing_of);
let Some(drawing) = drawing else {
continue;
};
let Some(frame) = view_frame(view, drawing) else {
faults.push(FrameFault::NoFrame { view_index });
continue;
};
faults.extend(annotation_faults(document, view.id(), &frame));
}
faults
}
fn annotation_faults(
document: &AnatomicalSheetDocument,
view_id: &str,
frame: &Frame,
) -> Vec<FrameFault> {
document
.annotations
.iter()
.enumerate()
.filter(|(_, a)| a.view_id() == view_id)
.filter_map(|(annotation_index, annotation)| {
let placement = placement(geometry_of(annotation)?, frame);
(placement != Placement::InFrame).then_some(FrameFault::Annotation {
annotation_index,
placement,
})
})
.collect()
}
fn geometry_of(annotation: &Annotation) -> Option<&Geometry> {
match annotation {
Annotation::Observable(a) => a.geometry.as_ref(),
Annotation::DetailTrigger(a) => a.geometry.as_ref(),
}
}
+2
View File
@@ -4,5 +4,7 @@
//! at commit 756b7ef.
pub mod compose;
pub mod frame;
pub mod layer;
pub mod path;
pub mod svg;
+679
View File
@@ -0,0 +1,679 @@
//! Numbers and path data read with the SVG grammar (SVG 1.1 §8.3.9, §7.7), for the frame of a
//! view (`anatomy::frame`, V1-2.2 owner brief 2026-10-30, defect 3): a `viewBox` and the
//! `d` of a path annotation. Strict: anything a browser would stop reading at (a missing
//! number, a bad flag, an unknown command, a trailing comma, a number out of range) answers
//! `None`, never a guess. Curves and arcs are measured on their shape, not on their control
//! points; a moveto counts, as a subpath may start there.
/// The smallest box holding a set of points.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Bounds {
pub min_x: f64,
pub min_y: f64,
pub max_x: f64,
pub max_y: f64,
}
impl Bounds {
pub fn point(x: f64, y: f64) -> Self {
Self {
min_x: x,
min_y: y,
max_x: x,
max_y: y,
}
}
pub fn add(&mut self, x: f64, y: f64) {
self.min_x = self.min_x.min(x);
self.min_y = self.min_y.min(y);
self.max_x = self.max_x.max(x);
self.max_y = self.max_y.max(y);
}
}
/// A list of numbers separated by comma-wsp, surrounding whitespace allowed (`viewBox`).
pub fn number_list(value: &str) -> Option<Vec<f64>> {
let mut cursor = Cursor::new(value);
cursor.skip_space();
let mut numbers = Vec::new();
while !cursor.done() {
if !numbers.is_empty() {
cursor.separator()?;
}
numbers.push(cursor.number()?);
cursor.skip_space();
}
Some(numbers)
}
/// The bounds of every point `d` draws; `None` when a browser would not read all of it.
pub fn path_bounds(d: &str) -> Option<Bounds> {
let mut cursor = Cursor::new(d);
let mut pen = Pen::default();
cursor.skip_space();
if !matches!(cursor.peek(), Some(b'M' | b'm')) {
return None;
}
while let Some(command) = cursor.command() {
cursor.skip_space();
if matches!(command, b'Z' | b'z') {
pen.close();
continue;
}
loop {
pen.segment(command, &mut cursor)?;
if !cursor.more_parameters()? {
break;
}
}
}
if !cursor.done() {
return None;
}
pen.bounds
}
/// A position in the text being read.
struct Cursor<'a> {
bytes: &'a [u8],
at: usize,
}
fn is_space(byte: u8) -> bool {
matches!(byte, b' ' | b'\t' | b'\n' | b'\r' | b'\x0C')
}
impl<'a> Cursor<'a> {
fn new(text: &'a str) -> Self {
Self {
bytes: text.as_bytes(),
at: 0,
}
}
fn done(&self) -> bool {
self.at >= self.bytes.len()
}
fn peek(&self) -> Option<u8> {
self.bytes.get(self.at).copied()
}
fn skip_space(&mut self) {
while self.peek().is_some_and(is_space) {
self.at += 1;
}
}
/// comma-wsp between two numbers: whitespace, at most one comma, whitespace.
fn separator(&mut self) -> Option<()> {
self.skip_space();
if self.peek() == Some(b',') {
self.at += 1;
self.skip_space();
}
self.starts_number().then_some(())
}
fn starts_number(&self) -> bool {
self.peek()
.is_some_and(|b| b.is_ascii_digit() || matches!(b, b'+' | b'-' | b'.'))
}
/// After a parameter group: another one follows (`Some(true)`), a command or the end
/// does (`Some(false)`); a comma before anything but a number is an error.
fn more_parameters(&mut self) -> Option<bool> {
self.skip_space();
if self.peek() == Some(b',') {
return self.separator().map(|()| true);
}
Some(self.starts_number())
}
fn command(&mut self) -> Option<u8> {
let byte = self
.peek()
.filter(|b| b"MmZzLlHhVvCcSsQqTtAa".contains(b))?;
self.at += 1;
Some(byte)
}
/// `sign? (digits ('.' digits?)? | '.' digits) (('e'|'E') sign? digits)?`, finite.
fn number(&mut self) -> Option<f64> {
let start = self.at;
if matches!(self.peek(), Some(b'+' | b'-')) {
self.at += 1;
}
let integer = self.digits();
let mut fraction = 0;
if self.peek() == Some(b'.') {
self.at += 1;
fraction = self.digits();
}
if integer == 0 && fraction == 0 {
return None;
}
if matches!(self.peek(), Some(b'e' | b'E')) {
let mark = self.at;
self.at += 1;
if matches!(self.peek(), Some(b'+' | b'-')) {
self.at += 1;
}
if self.digits() == 0 {
self.at = mark;
}
}
let text = std::str::from_utf8(&self.bytes[start..self.at]).ok()?;
text.parse::<f64>().ok().filter(|n| n.is_finite())
}
fn digits(&mut self) -> usize {
let start = self.at;
while self.peek().is_some_and(|b| b.is_ascii_digit()) {
self.at += 1;
}
self.at - start
}
/// An arc flag: one `0` or `1`, which needs no separator after it.
fn flag(&mut self) -> Option<bool> {
let flag = match self.peek()? {
b'0' => false,
b'1' => true,
_ => return None,
};
self.at += 1;
Some(flag)
}
/// `count` numbers separated by comma-wsp.
fn numbers<const N: usize>(&mut self) -> Option<[f64; N]> {
let mut out = [0.0; N];
for (index, slot) in out.iter_mut().enumerate() {
if index > 0 {
self.separator()?;
}
*slot = self.number()?;
}
Some(out)
}
fn arc_parameters(&mut self) -> Option<Arc> {
let [rx, ry, rotation] = self.numbers::<3>()?;
self.separator_before_flag()?;
let large = self.flag()?;
self.separator_before_flag()?;
let sweep = self.flag()?;
self.separator()?;
let [x, y] = self.numbers::<2>()?;
Some(Arc {
rx,
ry,
rotation,
large,
sweep,
to: (x, y),
})
}
fn separator_before_flag(&mut self) -> Option<()> {
self.skip_space();
if self.peek() == Some(b',') {
self.at += 1;
self.skip_space();
}
matches!(self.peek(), Some(b'0' | b'1')).then_some(())
}
}
struct Arc {
rx: f64,
ry: f64,
rotation: f64,
large: bool,
sweep: bool,
to: (f64, f64),
}
/// The current point, the subpath start, the previous control point (for `S` and `T`), and
/// the bounds so far.
#[derive(Default)]
struct Pen {
at: (f64, f64),
start: (f64, f64),
cubic_control: Option<(f64, f64)>,
quadratic_control: Option<(f64, f64)>,
bounds: Option<Bounds>,
}
impl Pen {
fn add(&mut self, (x, y): (f64, f64)) {
match &mut self.bounds {
Some(bounds) => bounds.add(x, y),
None => self.bounds = Some(Bounds::point(x, y)),
}
}
fn close(&mut self) {
self.at = self.start;
self.cubic_control = None;
self.quadratic_control = None;
}
/// One parameter group of `command`; a moveto's later pairs are linetos.
fn segment(&mut self, command: u8, cursor: &mut Cursor<'_>) -> Option<()> {
let relative = command.is_ascii_lowercase();
let origin = if relative { self.at } else { (0.0, 0.0) };
let point = |x: f64, y: f64| (origin.0 + x, origin.1 + y);
let (mut cubic, mut quadratic) = (None, None);
match command.to_ascii_uppercase() {
b'M' => {
let [x, y] = cursor.numbers::<2>()?;
self.at = point(x, y);
self.start = self.at;
self.add(self.at);
self.cubic_control = None;
self.quadratic_control = None;
return self.linetos(relative, cursor);
}
b'L' => {
let [x, y] = cursor.numbers::<2>()?;
self.line(point(x, y));
}
b'H' => {
let [x] = cursor.numbers::<1>()?;
self.line((origin.0 + x, self.at.1));
}
b'V' => {
let [y] = cursor.numbers::<1>()?;
self.line((self.at.0, origin.1 + y));
}
b'C' => {
let [x1, y1, x2, y2, x, y] = cursor.numbers::<6>()?;
cubic = Some(self.cubic(point(x1, y1), point(x2, y2), point(x, y)));
}
b'S' => {
let [x2, y2, x, y] = cursor.numbers::<4>()?;
let first = reflect(self.cubic_control, self.at);
cubic = Some(self.cubic(first, point(x2, y2), point(x, y)));
}
b'Q' => {
let [x1, y1, x, y] = cursor.numbers::<4>()?;
quadratic = Some(self.quadratic(point(x1, y1), point(x, y)));
}
b'T' => {
let [x, y] = cursor.numbers::<2>()?;
let control = reflect(self.quadratic_control, self.at);
quadratic = Some(self.quadratic(control, point(x, y)));
}
_ => {
let mut arc = cursor.arc_parameters()?;
arc.to = point(arc.to.0, arc.to.1);
self.arc(&arc);
}
}
self.cubic_control = cubic;
self.quadratic_control = quadratic;
Some(())
}
/// The pairs after a moveto's first one.
fn linetos(&mut self, relative: bool, cursor: &mut Cursor<'_>) -> Option<()> {
while cursor.more_parameters()? {
let [x, y] = cursor.numbers::<2>()?;
let to = if relative {
(self.at.0 + x, self.at.1 + y)
} else {
(x, y)
};
self.line(to);
}
Some(())
}
fn line(&mut self, to: (f64, f64)) {
self.add(to);
self.at = to;
}
/// Adds the curve's extremes; answers its second control point.
fn cubic(&mut self, c1: (f64, f64), c2: (f64, f64), to: (f64, f64)) -> (f64, f64) {
let from = self.at;
for t in cubic_extremes(from.0, c1.0, c2.0, to.0)
.into_iter()
.chain(cubic_extremes(from.1, c1.1, c2.1, to.1))
.flatten()
{
self.add((
cubic_at(from.0, c1.0, c2.0, to.0, t),
cubic_at(from.1, c1.1, c2.1, to.1, t),
));
}
self.line(to);
c2
}
/// Adds the curve's extremes; answers its control point.
fn quadratic(&mut self, control: (f64, f64), to: (f64, f64)) -> (f64, f64) {
let from = self.at;
for t in [
quadratic_extreme(from.0, control.0, to.0),
quadratic_extreme(from.1, control.1, to.1),
]
.into_iter()
.flatten()
{
self.add((
quadratic_at(from.0, control.0, to.0, t),
quadratic_at(from.1, control.1, to.1, t),
));
}
self.line(to);
control
}
/// SVG 1.1 F.6: an arc to the current point draws nothing, a zero radius draws a line;
/// otherwise the ellipse's extremes inside the sweep count.
fn arc(&mut self, arc: &Arc) {
if arc.to == self.at {
return;
}
if arc.rx == 0.0 || arc.ry == 0.0 {
self.line(arc.to);
return;
}
let ellipse = Ellipse::through(self.at, arc);
for angle in ellipse.extreme_angles() {
if ellipse.sweeps(angle) {
self.add(ellipse.at(angle));
}
}
self.line(arc.to);
}
}
/// The reflection of the previous control point about the current point, or the current point.
fn reflect(control: Option<(f64, f64)>, at: (f64, f64)) -> (f64, f64) {
control.map_or(at, |(x, y)| (2.0 * at.0 - x, 2.0 * at.1 - y))
}
fn cubic_at(p0: f64, p1: f64, p2: f64, p3: f64, t: f64) -> f64 {
let s = 1.0 - t;
s * s * s * p0 + 3.0 * s * s * t * p1 + 3.0 * s * t * t * p2 + t * t * t * p3
}
fn quadratic_at(p0: f64, p1: f64, p2: f64, t: f64) -> f64 {
let s = 1.0 - t;
s * s * p0 + 2.0 * s * t * p1 + t * t * p2
}
fn inside_unit(t: f64) -> Option<f64> {
(t > 0.0 && t < 1.0).then_some(t)
}
/// The parameters in (0, 1) where one coordinate of a cubic stops growing or shrinking.
fn cubic_extremes(p0: f64, p1: f64, p2: f64, p3: f64) -> [Option<f64>; 2] {
let a = -p0 + 3.0 * p1 - 3.0 * p2 + p3;
let b = 2.0 * (p0 - 2.0 * p1 + p2);
let c = p1 - p0;
if a.abs() < 1e-12 {
if b.abs() < 1e-12 {
return [None, None];
}
return [inside_unit(-c / b), None];
}
let discriminant = b * b - 4.0 * a * c;
if discriminant < 0.0 {
return [None, None];
}
let root = discriminant.sqrt();
[
inside_unit((-b + root) / (2.0 * a)),
inside_unit((-b - root) / (2.0 * a)),
]
}
fn quadratic_extreme(p0: f64, p1: f64, p2: f64) -> Option<f64> {
let denominator = p0 - 2.0 * p1 + p2;
if denominator.abs() < 1e-12 {
return None;
}
inside_unit((p0 - p1) / denominator)
}
/// An arc in its centre parameterisation (SVG 1.1 F.6.5, radii scaled up when too small).
struct Ellipse {
centre: (f64, f64),
rx: f64,
ry: f64,
cos: f64,
sin: f64,
start: f64,
sweep: f64,
}
impl Ellipse {
fn through(from: (f64, f64), arc: &Arc) -> Self {
let (sin, cos) = arc.rotation.to_radians().sin_cos();
let (mut rx, mut ry) = (arc.rx.abs(), arc.ry.abs());
let half = ((from.0 - arc.to.0) / 2.0, (from.1 - arc.to.1) / 2.0);
let x1 = cos * half.0 + sin * half.1;
let y1 = -sin * half.0 + cos * half.1;
let lambda = (x1 * x1) / (rx * rx) + (y1 * y1) / (ry * ry);
if lambda > 1.0 {
rx *= lambda.sqrt();
ry *= lambda.sqrt();
}
let numerator = rx * rx * ry * ry - rx * rx * y1 * y1 - ry * ry * x1 * x1;
let denominator = rx * rx * y1 * y1 + ry * ry * x1 * x1;
let sign = if arc.large == arc.sweep { -1.0 } else { 1.0 };
let factor = sign * (numerator / denominator).max(0.0).sqrt();
let (cx1, cy1) = (factor * rx * y1 / ry, -factor * ry * x1 / rx);
let centre = (
cos * cx1 - sin * cy1 + (from.0 + arc.to.0) / 2.0,
sin * cx1 + cos * cy1 + (from.1 + arc.to.1) / 2.0,
);
let start = ((y1 - cy1) / ry).atan2((x1 - cx1) / rx);
let end = ((-y1 - cy1) / ry).atan2((-x1 - cx1) / rx);
let mut sweep = (end - start).rem_euclid(std::f64::consts::TAU);
if !arc.sweep && sweep > 0.0 {
sweep -= std::f64::consts::TAU;
}
Self {
centre,
rx,
ry,
cos,
sin,
start,
sweep,
}
}
fn at(&self, angle: f64) -> (f64, f64) {
let (s, c) = angle.sin_cos();
(
self.centre.0 + self.rx * self.cos * c - self.ry * self.sin * s,
self.centre.1 + self.rx * self.sin * c + self.ry * self.cos * s,
)
}
/// The four angles where x or y of the whole ellipse is extreme.
fn extreme_angles(&self) -> [f64; 4] {
let x = (-self.ry * self.sin).atan2(self.rx * self.cos);
let y = (self.ry * self.cos).atan2(self.rx * self.sin);
let pi = std::f64::consts::PI;
[x, x + pi, y, y + pi]
}
fn sweeps(&self, angle: f64) -> bool {
let tau = std::f64::consts::TAU;
if self.sweep >= 0.0 {
(angle - self.start).rem_euclid(tau) <= self.sweep
} else {
(self.start - angle).rem_euclid(tau) <= -self.sweep
}
}
}
#[cfg(test)]
#[allow(clippy::unwrap_used)]
mod tests {
use super::*;
/// A deterministic generator for the sampled comparisons.
struct Lcg(u64);
impl Lcg {
fn next(&mut self, low: f64, high: f64) -> f64 {
self.0 = self
.0
.wrapping_mul(6_364_136_223_846_793_005)
.wrapping_add(1_442_695_040_888_963_407);
low + (high - low) * ((self.0 >> 11) as f64 / (1_u64 << 53) as f64)
}
}
fn sampled(points: impl Iterator<Item = (f64, f64)>) -> Bounds {
let mut bounds: Option<Bounds> = None;
for (x, y) in points {
match &mut bounds {
Some(b) => b.add(x, y),
None => bounds = Some(Bounds::point(x, y)),
}
}
bounds.unwrap()
}
/// The computed box holds every sampled point and is no larger than the samples show.
fn assert_tight(computed: Bounds, samples: Bounds, label: &str) {
let tolerance = 1e-6 * (1.0 + (samples.max_x - samples.min_x).abs());
let pairs = [
(computed.min_x, samples.min_x),
(computed.min_y, samples.min_y),
(-computed.max_x, -samples.max_x),
(-computed.max_y, -samples.max_y),
];
for (outer, inner) in pairs {
assert!(
outer <= inner + 1e-9,
"{label}: {computed:?} misses {samples:?}"
);
assert!(
inner - outer < tolerance * 10.0,
"{label}: {computed:?} vs {samples:?}"
);
}
}
#[test]
fn cubic_bounds_follow_the_curve() {
let mut rng = Lcg(7);
for case in 0..500 {
let p: Vec<f64> = (0..8).map(|_| rng.next(-50.0, 50.0)).collect();
let d = format!(
"M{} {}C{} {} {} {} {} {}",
p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]
);
let computed = path_bounds(&d).unwrap();
let samples = sampled((0..=20_000).map(|i| {
let t = f64::from(i) / 20_000.0;
(
cubic_at(p[0], p[2], p[4], p[6], t),
cubic_at(p[1], p[3], p[5], p[7], t),
)
}));
assert_tight(computed, samples, &format!("cubic {case}: {d}"));
}
}
#[test]
fn arc_bounds_follow_the_arc() {
let mut rng = Lcg(11);
for case in 0..500 {
let from = (rng.next(-20.0, 20.0), rng.next(-20.0, 20.0));
let arc = Arc {
rx: rng.next(0.5, 30.0),
ry: rng.next(0.5, 30.0),
rotation: rng.next(-360.0, 360.0),
large: rng.next(0.0, 1.0) < 0.5,
sweep: rng.next(0.0, 1.0) < 0.5,
to: (rng.next(-20.0, 20.0), rng.next(-20.0, 20.0)),
};
let d = format!(
"M{} {}A{} {} {} {} {} {} {}",
from.0,
from.1,
arc.rx,
arc.ry,
arc.rotation,
u8::from(arc.large),
u8::from(arc.sweep),
arc.to.0,
arc.to.1
);
let computed = path_bounds(&d).unwrap();
let ellipse = Ellipse::through(from, &arc);
let end = ellipse.at(ellipse.start + ellipse.sweep);
assert!(
(end.0 - arc.to.0).abs() < 1e-6 && (end.1 - arc.to.1).abs() < 1e-6,
"arc {case}: the parameterisation ends at the endpoint"
);
let samples = sampled(
(0..=20_000)
.map(|i| ellipse.at(ellipse.start + ellipse.sweep * f64::from(i) / 20_000.0)),
);
assert_tight(computed, samples, &format!("arc {case}: {d}"));
}
}
#[test]
fn the_grammar_is_read_as_a_browser_reads_it() {
let read = |d: &str| path_bounds(d).map(|b| (b.min_x, b.min_y, b.max_x, b.max_y));
assert_eq!(read("M1 2L3 4"), Some((1.0, 2.0, 3.0, 4.0)));
assert_eq!(read("m1 2 3 4"), Some((1.0, 2.0, 4.0, 6.0)));
assert_eq!(read("M1,2,3,4"), Some((1.0, 2.0, 3.0, 4.0)));
assert_eq!(read("M.5.5L1-1"), Some((0.5, -1.0, 1.0, 0.5)));
assert_eq!(read("M0 0h5v-2H1V9z"), Some((0.0, -2.0, 5.0, 9.0)));
assert_eq!(read("M0 0a1 1 0 1010 0"), Some((0.0, 0.0, 10.0, 5.0)));
assert_eq!(read("M0 0 1e1 1E-1"), Some((0.0, 0.0, 10.0, 0.1)));
assert_eq!(read(" M0 0 Z m1 1 l1 1 "), Some((0.0, 0.0, 2.0, 2.0)));
for broken in [
"",
"L1 1",
"M",
"M1",
"M1 1L",
"M1 1,",
"M1 1,L2 2",
"M1 1 L 2",
"M1 1X2 2",
"M1e 1",
"M1 1A1 1 0 2 0 3 3",
"M1 1e999 1",
"M1 1 L2 2;",
"M--1 1",
] {
assert_eq!(read(broken), None, "{broken:?}");
}
}
#[test]
fn number_lists_follow_the_svg_grammar() {
assert_eq!(
number_list(" 0,0 10 ,10 "),
Some(vec![0.0, 0.0, 10.0, 10.0])
);
assert_eq!(
number_list("-0 +1e1 .5 5."),
Some(vec![-0.0, 10.0, 0.5, 5.0])
);
for broken in [
"0,,1", "0 1,", ",0", "0x1", "1px", "1e999", "Infinity", "NaN",
] {
assert_eq!(number_list(broken), None, "{broken:?}");
}
assert_eq!(number_list(""), Some(vec![]));
}
}
+5 -2
View File
@@ -21,7 +21,7 @@ use super::fingerprint::document_fingerprint;
use super::index::SheetIndex;
use super::index_data::{names, node_keys, sorted, spine_ids};
use super::loaded::{Drawing, read_drawing};
use super::report::{SheetReport, referenced_asset_ids, sheet_report};
use super::report::{SheetReport, frame_issues, referenced_asset_ids, sheet_report};
use super::review::DigestError;
use super::schema::{AnatomicalSheetDocument, LocalizedText};
use super::verdict::{read_document, sha256_hex};
@@ -270,12 +270,15 @@ impl PreviewSheet {
}
pub fn state(&self) -> Result<PreviewState, DigestError> {
let report = sheet_report(
let mut report = sheet_report(
&self.document,
self.document_bytes,
&self.drawing_sizes(),
None,
)?;
report.issues.extend(frame_issues(&self.document, |id| {
self.drawing(id).and_then(|d| d.as_ref().ok())
}));
Ok(PreviewState {
status: self.status,
fingerprint: self.fingerprint.clone(),
+60
View File
@@ -12,11 +12,19 @@ use super::caps::{CapsReport, caps_report};
use super::review::{Completeness, DigestError, ReviewGroup, completeness, review_groups};
use super::schema::{AnatomicalSheetDocument, Annotation};
use super::validate::{SheetIssue, SheetIssueSeverity, validate_sheet_document};
use crate::anatomy::frame::{FrameFault, Placement, frame_faults};
use crate::anatomy::svg::Element;
/// The submission rule of §6.7 the integrity tier does not hold: a draft may keep an
/// annotation without geometry, a submitted revision may not.
pub const GEOMETRY_MISSING: &str = "annotation.geometry.missing";
/// An annotation not entirely inside the frame of its view, or whose path data a browser would
/// not read whole (V1-2.2 owner brief 2026-10-30, `anatomy::frame`).
pub const OUT_OF_FRAME: &str = "annotation.geometry.out_of_frame";
/// A view drawn on a drawing with neither a `view_box` nor a usable drawing `viewBox`.
pub const NO_FRAME: &str = "view.frame.unknown";
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
#[cfg_attr(feature = "ts", derive(TS), ts(export))]
pub struct SheetReport {
@@ -79,3 +87,55 @@ pub fn referenced_asset_ids(document: &AnatomicalSheetDocument) -> Vec<&str> {
.filter(|id| seen.insert(*id))
.collect()
}
/// The frame issues of `document` on the drawings `drawing_of` gives by asset id (read, with no
/// removal): the same faults for the verdict and the preview. A view whose drawing is not given
/// is not measured.
pub fn frame_issues<'a>(
document: &AnatomicalSheetDocument,
drawing_of: impl Fn(&str) -> Option<&'a Element>,
) -> Vec<SheetIssue> {
frame_faults(document, drawing_of)
.into_iter()
.map(|fault| frame_issue(document, &fault))
.collect()
}
fn frame_issue(document: &AnatomicalSheetDocument, fault: &FrameFault) -> SheetIssue {
let (code, path, message) = match *fault {
FrameFault::NoFrame { view_index } => (
NO_FRAME,
format!("views[{view_index}]"),
format!(
"View \"{}\" has neither a view_box nor a usable drawing viewBox",
document.views[view_index].id()
),
),
FrameFault::Annotation {
annotation_index,
placement,
} => {
let annotation = &document.annotations[annotation_index];
let what = if placement == Placement::Unreadable {
"has path data that cannot be read whole"
} else {
"is not entirely inside the frame"
};
(
OUT_OF_FRAME,
format!("annotations[{annotation_index}].geometry"),
format!(
"Annotation \"{}\" {what} of view \"{}\"",
annotation.id(),
annotation.view_id()
),
)
}
};
SheetIssue {
code: code.to_owned(),
severity: SheetIssueSeverity::Error,
path,
message,
}
}
+54 -16
View File
@@ -20,13 +20,15 @@ use ts_rs::TS;
use super::caps::CapsReport;
use super::fingerprint::{FingerprintError, document_fingerprint};
use super::report::{SheetReport, referenced_asset_ids, sheet_report};
use super::report::{
NO_FRAME, OUT_OF_FRAME, SheetReport, frame_issues, referenced_asset_ids, sheet_report,
};
use super::review::{Completeness, ElementChange, ReviewGroup, change_list};
use super::schema::AnatomicalSheetDocument;
use super::size::document_text_bytes;
use super::validate::{SheetIssue, SheetIssueSeverity};
use crate::anatomy::svg::serialize::stored_form;
use crate::anatomy::svg::{processing_instructions, read_svg};
use crate::anatomy::svg::{Element, processing_instructions, read_svg};
use crate::domain::js::parse_json;
/// The format of the verdict object, bumped with any change of its meaning.
@@ -49,6 +51,9 @@ pub mod codes {
pub const SVG_REJECTED: &str = "verification.integrity.svg_rejected";
pub const SVG_REMOVAL: &str = "verification.integrity.svg_removal";
pub const SVG_NOT_CANONICAL: &str = "verification.integrity.svg_not_canonical";
/// An annotation outside the frame of its view, or a view without a frame (V1-2.2):
/// measured on the views whose drawing reads clean.
pub const OUT_OF_FRAME: &str = "verification.validation.out_of_frame";
pub const FINGERPRINT: &str = "verification.integrity.fingerprint";
}
@@ -173,11 +178,19 @@ fn verify(input: &VerdictInput<'_>, verdict: &mut Verdict) -> Result<(), &'stati
let drawings = check_drawings(&document.typed, &input.drawings);
let sizes: Vec<u64> = drawings.iter().map(|d| d.size).collect();
let base_typed = base.as_ref().map(|b| &b.typed);
let report = sheet_report(&document.typed, document.bytes, &sizes, base_typed)
let mut report = sheet_report(&document.typed, document.bytes, &sizes, base_typed)
.map_err(|_| codes::FINGERPRINT)?;
let roots: HashMap<&str, &Element> = drawings
.iter()
.filter_map(|d| Some((d.check.asset_id.as_str(), d.root.as_ref()?)))
.collect();
report
.issues
.extend(frame_issues(&document.typed, |id| roots.get(id).copied()));
for code in rule_failures(&report)
.into_iter()
.chain(drawing_failures(&drawings))
.chain(frame_failures(&report))
{
fail(verdict, code);
}
@@ -262,7 +275,9 @@ fn rule_failures(report: &SheetReport) -> Vec<&'static str> {
.filter(|i| i.severity == SheetIssueSeverity::Error)
};
let mut out = Vec::new();
if errors().any(|i| i.code != super::report::GEOMETRY_MISSING) {
let rule =
|code: &str| ![super::report::GEOMETRY_MISSING, OUT_OF_FRAME, NO_FRAME].contains(&code);
if errors().any(|i| rule(&i.code)) {
out.push(codes::RULES);
}
if errors().any(|i| i.code == super::report::GEOMETRY_MISSING) {
@@ -274,10 +289,22 @@ fn rule_failures(report: &SheetReport) -> Vec<&'static str> {
out
}
/// The frame code when a frame issue was found (after the drawing faults: a view is measured
/// only on a drawing that reads clean).
fn frame_failures(report: &SheetReport) -> Option<&'static str> {
report
.issues
.iter()
.any(|i| i.code == OUT_OF_FRAME || i.code == NO_FRAME)
.then_some(codes::OUT_OF_FRAME)
}
struct CheckedDrawing {
check: DrawingCheck,
/// The size the caps count: the object's, else the row's.
size: u64,
/// The drawing as read, when it is `Ok` (the frame of its views).
root: Option<Element>,
}
/// Every drawing the views reference, in view order, against its row and its bytes.
@@ -292,12 +319,14 @@ fn check_drawings(
None => CheckedDrawing {
check: drawing_check(asset_id, None, DrawingResult::Missing, None),
size: 0,
root: None,
},
Some(row) => {
let (result, detail) = check_bytes(row);
let (result, detail, root) = check_bytes(row);
CheckedDrawing {
check: drawing_check(asset_id, Some(row), result, detail),
size: row.bytes.map_or(row.byte_size, |b| b.len() as u64),
root,
}
}
})
@@ -319,34 +348,43 @@ fn drawing_check(
}
}
/// Size, then the hash of the bytes against the row (the object key), then the reader.
fn check_bytes(row: &VerdictDrawing<'_>) -> (DrawingResult, Option<String>) {
/// Size, then the hash of the bytes against the row (the object key), then the reader; the
/// root read when the drawing is `Ok`.
fn check_bytes(row: &VerdictDrawing<'_>) -> (DrawingResult, Option<String>, Option<Element>) {
let Some(bytes) = row.bytes else {
return (DrawingResult::Missing, None);
return (DrawingResult::Missing, None, None);
};
if bytes.len() as u64 != row.byte_size {
return (DrawingResult::SizeMismatch, None);
return (DrawingResult::SizeMismatch, None, None);
}
if sha256_hex(bytes) != row.sha256 {
return (DrawingResult::HashMismatch, None);
return (DrawingResult::HashMismatch, None, None);
}
let Ok(text) = std::str::from_utf8(bytes) else {
return (DrawingResult::SvgRejected, Some("malformed".to_owned()));
return (
DrawingResult::SvgRejected,
Some("malformed".to_owned()),
None,
);
};
match read_svg(text) {
Err(rejection) => (
DrawingResult::SvgRejected,
Some(rejection.reason().to_owned()),
None,
),
Ok(read) if !read.removed.is_empty() => (
DrawingResult::SvgRemoval,
Some(read.removed.join(", ")),
None,
),
Ok(read) if !read.removed.is_empty() => {
(DrawingResult::SvgRemoval, Some(read.removed.join(", ")))
}
Ok(_) if !processing_instructions(text).is_empty() => (
DrawingResult::SvgRejected,
Some("processing_instruction".to_owned()),
None,
),
Ok(read) if stored_form(&read.root) != text => (DrawingResult::SvgNotCanonical, None),
Ok(_) => (DrawingResult::Ok, None),
Ok(read) if stored_form(&read.root) != text => (DrawingResult::SvgNotCanonical, None, None),
Ok(read) => (DrawingResult::Ok, None, Some(read.root)),
}
}