mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-18 16:37:32 +00:00
A line graph whose style record draws its lines as shapes now opens as a live graph with Draw Filled Lines on, and its lineShapeWidth becomes the Line Width (3 pt reads as the default). The flag is ignored when the points are not connected, as the published file format specification says (printed pp. 147-148). Saving writes both values in the Gy record. - Widths from 0.01 to 100 pt are kept. A wider Line Width, a width under 0.01 pt with filled lines, and filled lines without connected points are saved as the graph's art with the existing warning. - In a filled-line series, a filled path with the thin black band outline is read as a band and does not set the series stroke. A filled path with another outline must be a square marker or legend swatch; otherwise the graph keeps its art as plain objects. - The reader in crates/eps/src/import/ai/read/graph.rs reads each value the writer in crates/eps/src/ai_graph.rs writes; the save-then-open tests cover the default, 8 pt and 150 pt widths in both .ai forms.
787 lines
37 KiB
Rust
787 lines
37 KiB
Rust
//! A live graph's records, which the legacy `.ai` writer ([`crate::legacy_ai`]) and the editing data
|
||
//! writer ([`crate::ai_editing`]) both write around a graph's group (Adobe Illustrator File Format
|
||
//! Specification, version 7.0, §17 and appendix A): `%_Gs`, the functional records on `%_` lines
|
||
//! (`Gb`, `Gy`, `Gd`, three `Ga` … `GA` axes, `Gz`, `Gc` cells and `GC`), the drawn art in one group
|
||
//! with each series' group followed by `%_2 column 0 0 Go`, then `%_GS`.
|
||
//!
|
||
//! A graph is written so only when the `.ai` reader (`import::ai::read::graph`) reads every record
|
||
//! back as the same graph: one of the four graph types it reads (grouped and stacked column, line,
|
||
//! area), the settings it keeps, a table it holds, and drawn art it attaches the graph to (each
|
||
//! series' group a direct member of the graph's, of paths painted with one solid fill and one plain
|
||
//! line, and the plot's left and bottom edges drawn as stroked lines). Any other graph is written as
|
||
//! its art, with a warning.
|
||
|
||
use std::collections::HashMap;
|
||
use std::fmt::Write;
|
||
|
||
use kurbo::{PathSeg, Point};
|
||
use vectorcraft_color::{BlendMode, Paint};
|
||
use vectorcraft_doc::{
|
||
Appearance, AppearanceItem, DEFAULT_FILLED_LINE_WIDTH, FILLED_LINE_OUTLINE_WIDTH, GraphKind, GraphSpec, LabelStyles, MAX_GRAPH_CATEGORIES,
|
||
MAX_GRAPH_SERIES, MIN_FILLED_LINE_WIDTH, Node, NodeId, NodeKind, PiePosition, PieSort, TickLength, ValueAxisSide,
|
||
};
|
||
use vectorcraft_effects::stroke;
|
||
use vectorcraft_geom::{Affine, Rect};
|
||
|
||
use crate::ps;
|
||
|
||
/// Most cells of a graph's table, its label row and column included.
|
||
const MAX_CELLS: usize = 2_600_000;
|
||
|
||
/// Longest cell string, in bytes (appendix A, `Gc`).
|
||
const MAX_CELL_TEXT: usize = 255;
|
||
|
||
/// Most characters of the text before or after a value axis' numbers (appendix A, `Ga`, `GA`).
|
||
const MAX_AFFIX: usize = 9;
|
||
|
||
/// Most tick marks per division the reader keeps.
|
||
const MAX_TICK_MARKS: usize = 20;
|
||
|
||
/// Most divisions of a value axis with set values the reader keeps.
|
||
const MAX_DIVISIONS: usize = 100;
|
||
|
||
/// How far an axis line may be from the plot's edge, in points.
|
||
const EDGE: f64 = 0.01;
|
||
|
||
/// Most values one `Gc` takes.
|
||
const CELLS_PER_RECORD: usize = 15;
|
||
|
||
/// Widest `lineShapeWidth` the records give, in points (appendix A, `Gy`).
|
||
const MAX_LINE_WIDTH: f64 = 100.0;
|
||
|
||
/// A graph's records: what goes before its group (`%_Gs` to `%_GC`), and the `Go` line that follows
|
||
/// each series' group, by the group's id. `%_GS` follows the group.
|
||
pub(crate) struct Records {
|
||
pub(crate) head: String,
|
||
pub(crate) tags: HashMap<NodeId, String>,
|
||
}
|
||
|
||
/// The line that ends a graph's records, after its group.
|
||
pub(crate) const END: &str = "%_GS";
|
||
|
||
/// The records of graph `n` (a group holding [`vectorcraft_doc::NodeExtras::graph`]), its art written
|
||
/// through `to_art`; `None` when the reader would not read them back as the same graph.
|
||
pub(crate) fn records(n: &Node, to_art: Affine) -> Option<Records> {
|
||
let g = n.extras().graph.as_deref()?;
|
||
let NodeKind::Group { children, clip: false } = &n.kind else { return None };
|
||
(n.visible && n.extras().mask.is_none() && all_shown(n)).then_some(())?;
|
||
let ty = kind_code(g.kind)?;
|
||
settings_kept(g).then_some(())?;
|
||
let (left_manual, left_min, left_max, left_step) = axis(g.ticks, g.axis_min, g.axis_max)?;
|
||
let (right_manual, right_min, right_max, right_step) = axis(g.right_ticks, g.right_axis_min, g.right_axis_max)?;
|
||
// The table as the graph draws it: `cells` leaves out rows and series past the model's limits.
|
||
let rows = g.rows.len();
|
||
let width = g.rows.iter().map(Vec::len).max().unwrap_or(0);
|
||
((1..=MAX_GRAPH_CATEGORIES).contains(&rows) && (1..=MAX_GRAPH_SERIES).contains(&width)).then_some(())?;
|
||
let cells = g.cells();
|
||
cells.iter().flatten().all(|v| v.is_none_or(f64::is_finite)).then_some(())?;
|
||
cells.iter().flatten().any(Option::is_some).then_some(())?;
|
||
let first_row = usize::from(!g.series.is_empty());
|
||
let first_col = usize::from(!g.categories.is_empty());
|
||
(g.series.is_empty() || g.series.len() == width).then_some(())?;
|
||
(g.categories.is_empty() || g.categories.len() == rows).then_some(())?;
|
||
let (total_rows, total_cols) = (rows + first_row, width + first_col);
|
||
total_rows.checked_mul(total_cols).filter(|c| *c <= MAX_CELLS)?;
|
||
g.series.iter().chain(&g.categories).all(|l| l.len() <= MAX_CELL_TEXT && !l.chars().any(char::is_control)).then_some(())?;
|
||
[&g.prefix, &g.suffix, &g.right_prefix, &g.right_suffix]
|
||
.iter()
|
||
.all(|a| a.chars().count() <= MAX_AFFIX && !a.chars().any(char::is_control))
|
||
.then_some(())?;
|
||
// The plot, and the art the reader attaches the graph to.
|
||
let r = g.rect;
|
||
(r.is_finite() && r.width() > 0.0 && r.height() > 0.0).then_some(())?;
|
||
let plot = to_art.transform_rect_bbox(r);
|
||
(plot.is_finite() && plot.width() > 0.0 && plot.height() > 0.0).then_some(())?;
|
||
let line = g.kind == GraphKind::Line;
|
||
let tags = series_groups(children, width, first_col, line, line && g.filled_lines)?;
|
||
draws_axes(n, r).then_some(())?;
|
||
let placed = n.geometric_bounds()?;
|
||
(r.x0 >= placed.x0 - EDGE && r.y0 >= placed.y0 - EDGE && r.x1 <= placed.x1 + EDGE && r.y1 <= placed.y1 + EDGE).then_some(())?;
|
||
|
||
let mut head = String::from("%_Gs\n");
|
||
let _ = writeln!(head, "%_{} {} {} {} Gb", real(plot.x0), real(plot.y1), real(plot.x1), real(plot.y0));
|
||
let flag = |b: bool| u8::from(b);
|
||
// `lineShapeWidth`: the width filled lines are drawn at, the graph's default included.
|
||
let _ = writeln!(
|
||
head,
|
||
"%_{ty} {} {} 14 {} {} {} {} {} 44 Gy",
|
||
flag(g.drop_shadow),
|
||
flag(g.first_row_in_front),
|
||
flag(g.mark_points),
|
||
flag(g.connect_points),
|
||
flag(g.filled_lines),
|
||
flag(g.legend_across_top),
|
||
real(g.line_width.unwrap_or(DEFAULT_FILLED_LINE_WIDTH))
|
||
);
|
||
let _ =
|
||
writeln!(head, "%_10 2 {} 0 {} {} {} Gd", flag(g.first_column_in_front), real(g.column_width), real(g.cluster_width), flag(g.edge_to_edge));
|
||
// Tick marks per division: 0 and 1 both mean one, at the labels, and the reader reads 0 as 1.
|
||
let (category_marks, left_marks, right_marks) = (g.category_tick_marks.max(1), g.tick_marks.max(1), g.right_tick_marks.max(1));
|
||
let _ = writeln!(head, "%_1 () Ga\n%_0 {} 0 0 0 {category_marks} {} () GA", tick(g.category_tick_length), flag(g.ticks_between_labels));
|
||
let _ = writeln!(head, "%_2 {} Ga", ps::bytes(g.prefix.as_bytes()));
|
||
let _ = writeln!(
|
||
head,
|
||
"%_{} {} {} {} {} {} 0 {} GA",
|
||
flag(left_manual),
|
||
tick(g.tick_length),
|
||
real(left_min),
|
||
real(left_max),
|
||
real(left_step),
|
||
left_marks,
|
||
ps::bytes(g.suffix.as_bytes())
|
||
);
|
||
let _ = writeln!(head, "%_4 {} Ga", ps::bytes(g.right_prefix.as_bytes()));
|
||
let _ = writeln!(
|
||
head,
|
||
"%_{} {} {} {} {} {} 0 {} GA",
|
||
flag(right_manual),
|
||
tick(g.right_tick_length),
|
||
real(right_min),
|
||
real(right_max),
|
||
real(right_step),
|
||
right_marks,
|
||
ps::bytes(g.right_suffix.as_bytes())
|
||
);
|
||
let _ = writeln!(head, "%_{total_rows} {total_cols} {first_row} {first_col} Gz");
|
||
let mut table = Table::new(&mut head);
|
||
if first_row == 1 {
|
||
if first_col == 1 {
|
||
table.text("");
|
||
}
|
||
for s in &g.series {
|
||
table.text(s);
|
||
}
|
||
}
|
||
for (i, row) in cells.iter().enumerate() {
|
||
if let Some(c) = g.categories.get(i) {
|
||
table.text(c);
|
||
}
|
||
for v in row {
|
||
match v {
|
||
Some(v) => table.num(*v),
|
||
None => table.text(""),
|
||
}
|
||
}
|
||
}
|
||
table.finish();
|
||
head.push_str("%_GC\n");
|
||
Some(Records { head, tags })
|
||
}
|
||
|
||
/// The `Gc` records of a table, its cells in rows: at most [`CELLS_PER_RECORD`] values each, one
|
||
/// string at most.
|
||
struct Table<'a> {
|
||
out: &'a mut String,
|
||
values: usize,
|
||
string: bool,
|
||
}
|
||
|
||
impl<'a> Table<'a> {
|
||
fn new(out: &'a mut String) -> Self {
|
||
Self { out, values: 0, string: false }
|
||
}
|
||
|
||
fn start(&mut self, string: bool) {
|
||
if self.values == CELLS_PER_RECORD || (string && self.string) {
|
||
self.finish();
|
||
}
|
||
self.out.push_str(if self.values == 0 { "%_" } else { " " });
|
||
self.values += 1;
|
||
self.string |= string;
|
||
}
|
||
|
||
fn text(&mut self, t: &str) {
|
||
self.start(true);
|
||
self.out.push_str(&ps::bytes(t.as_bytes()));
|
||
}
|
||
|
||
fn num(&mut self, v: f64) {
|
||
self.start(false);
|
||
self.out.push_str(&real(v));
|
||
}
|
||
|
||
fn finish(&mut self) {
|
||
if self.values > 0 {
|
||
self.out.push_str(" Gc\n");
|
||
}
|
||
(self.values, self.string) = (0, false);
|
||
}
|
||
}
|
||
|
||
/// `v` as a PostScript number that reads back as the same value.
|
||
fn real(v: f64) -> String {
|
||
if v == 0.0 {
|
||
"0".into()
|
||
} else if (1e-4..1e15).contains(&v.abs()) {
|
||
format!("{v}")
|
||
} else {
|
||
format!("{v:e}")
|
||
}
|
||
}
|
||
|
||
/// `graphType`: 5 grouped column, 6 stacked column, 7 line, 10 area; the reader reads no other type.
|
||
fn kind_code(k: GraphKind) -> Option<u8> {
|
||
match k {
|
||
GraphKind::Column => Some(5),
|
||
GraphKind::StackedColumn => Some(6),
|
||
GraphKind::Line => Some(7),
|
||
GraphKind::Area => Some(10),
|
||
_ => None,
|
||
}
|
||
}
|
||
|
||
/// `tickMarkType`: 13 none, 14 short, 15 the length of the plot.
|
||
fn tick(t: TickLength) -> u8 {
|
||
match t {
|
||
TickLength::None => 13,
|
||
TickLength::Short => 14,
|
||
TickLength::Full => 15,
|
||
}
|
||
}
|
||
|
||
/// Whether `g`'s settings are ones the records give and the reader keeps: a legend beside or across
|
||
/// the top, every series of the graph's type, one value axis on the left, lines filled only where
|
||
/// they connect the points (the records ignore the setting otherwise), a Line Width of 0.01 to
|
||
/// [`MAX_LINE_WIDTH`] points, with filled lines no series stroked as the bands' outline
|
||
/// ([`band_outline`]), which the reader reads as bands, no graph designs, label formatting or pie settings, column and
|
||
/// cluster widths of 1% to 1000%, and at most [`MAX_TICK_MARKS`] tick marks a division.
|
||
fn settings_kept(g: &GraphSpec) -> bool {
|
||
let percent = |p: f64| (1.0..=1000.0).contains(&p);
|
||
g.legend
|
||
&& g.series_kinds.iter().all(|k| k.is_none_or(|k| k == g.kind))
|
||
&& g.value_axis == ValueAxisSide::Left
|
||
&& !g.separate_scales
|
||
&& g.right_series.is_empty()
|
||
&& (g.connect_points || !g.filled_lines)
|
||
&& g.line_width.is_none_or(|w| (MIN_FILLED_LINE_WIDTH..=MAX_LINE_WIDTH).contains(&w))
|
||
&& !(g.kind == GraphKind::Line && g.filled_lines && g.series_paints.iter().any(|p| band_outline(&p.stroke.clone().zip(p.stroke_width))))
|
||
&& g.series_markers.iter().all(Option::is_none)
|
||
&& g.series_columns.iter().all(Option::is_none)
|
||
&& g.label_styles == LabelStyles::default()
|
||
&& !g.pie_legend_in_wedges
|
||
&& g.pie_position == PiePosition::Even
|
||
&& g.pie_sort == PieSort::None
|
||
&& percent(g.column_width)
|
||
&& percent(g.cluster_width)
|
||
&& [g.tick_marks, g.right_tick_marks, g.category_tick_marks].iter().all(|m| *m <= MAX_TICK_MARKS)
|
||
}
|
||
|
||
/// A value axis' `useManualValues`, lowest and highest value and `betweenValue`: automatic (no tick
|
||
/// count and no values), or a whole number of divisions (1 to [`MAX_DIVISIONS`]) between a lowest
|
||
/// and a higher highest value, which the reader reads back as the same count.
|
||
fn axis(ticks: usize, min: Option<f64>, max: Option<f64>) -> Option<(bool, f64, f64, f64)> {
|
||
match (ticks, min, max) {
|
||
(0, None, None) => Some((false, 0.0, 0.0, 0.0)),
|
||
(1..=MAX_DIVISIONS, Some(lo), Some(hi)) if lo.is_finite() && hi.is_finite() && hi > lo => {
|
||
let step = (hi - lo) / ticks as f64;
|
||
let n = (hi - lo) / step;
|
||
let exact = step > 0.0 && step.is_finite() && (n - n.round()).abs() <= 1e-6 * n.round().max(1.0) && n.round() == ticks as f64;
|
||
exact.then_some((true, lo, hi, step))
|
||
}
|
||
_ => None,
|
||
}
|
||
}
|
||
|
||
/// Whether `n` and everything in it is shown.
|
||
fn all_shown(n: &Node) -> bool {
|
||
n.visible && n.children().is_none_or(|c| c.iter().all(|c| all_shown(c)))
|
||
}
|
||
|
||
/// Whether `n` is shown, fully opaque, in Normal mode, not isolated and without an opacity mask or
|
||
/// effects: the reader keeps a series' paint only from groups and paths drawn so.
|
||
fn as_drawn(n: &Node) -> bool {
|
||
n.visible
|
||
&& n.opacity == 1.0
|
||
&& n.blend == BlendMode::Normal
|
||
&& !n.isolate
|
||
&& n.extras().mask.is_none()
|
||
&& !n.appearance.effects.iter().any(|e| e.visible)
|
||
}
|
||
|
||
/// The visible fill and line `p` is written with as one path object: a solid fill, and a solid
|
||
/// plain line with its weight, each opaque, in Normal mode and without effects of its own. `None`
|
||
/// when it has other paint, more than one of either, or isn't one path of one subpath.
|
||
#[allow(clippy::type_complexity)]
|
||
fn plain_paint(p: &Node) -> Option<(Option<Paint>, Option<(Paint, f64)>)> {
|
||
let NodeKind::Path { path, guide: false, clipping: false, .. } = &p.kind else { return None };
|
||
(path.subpaths.iter().filter(|sp| !sp.anchors.is_empty()).count() == 1).then_some(())?;
|
||
let (mut fill, mut line) = (None, None);
|
||
for item in &p.appearance.items {
|
||
let drawn = match item {
|
||
AppearanceItem::Fill(f) => f.visible && !f.paint.is_none(),
|
||
AppearanceItem::Stroke(s) => s.visible && !s.paint.is_none() && s.width > 0.0 && s.width.is_finite(),
|
||
};
|
||
if !drawn {
|
||
// The writers leave out what draws nothing; the reader reads nothing in its place.
|
||
continue;
|
||
}
|
||
let plain =
|
||
item.opacity() == 1.0 && item.blend() == BlendMode::Normal && item.effects().is_empty() && matches!(item.paint(), Paint::Solid { .. });
|
||
plain.then_some(())?;
|
||
match item {
|
||
AppearanceItem::Fill(f) if fill.is_none() && line.is_none() => fill = Some(f.paint.clone()),
|
||
AppearanceItem::Stroke(s) if line.is_none() && stroke::is_plain(s) => line = Some((s.paint.clone(), s.width)),
|
||
_ => return None,
|
||
}
|
||
}
|
||
Some((fill, line))
|
||
}
|
||
|
||
/// The `Go` line of each series' group among `children`: a group whose series index is one of the
|
||
/// `series` the table has, each once, of paths [`as_drawn`] with one fill and one line alike
|
||
/// ([`plain_paint`]), every path filled unless the graph draws lines (`line`). With filled lines
|
||
/// (`bands`), a filled path outlined as [`band_outline`] says is a band, any other filled path is a
|
||
/// [`square`] marker or swatch, and the line of the paths that are not bands is the series' line,
|
||
/// as the reader reads it. Its column is the
|
||
/// table's: after the label column when there is one (`first_col`). `None` when a series has no
|
||
/// such group.
|
||
fn series_groups(children: &[std::sync::Arc<Node>], series: usize, first_col: usize, line: bool, bands: bool) -> Option<HashMap<NodeId, String>> {
|
||
let mut tags = HashMap::new();
|
||
let mut seen = vec![false; series];
|
||
for c in children {
|
||
let Some(s) = c.extras().series_index else { continue };
|
||
let s = usize::try_from(s).ok().filter(|s| *s < series)?;
|
||
let slot = seen.get_mut(s)?;
|
||
(!*slot).then_some(())?;
|
||
*slot = true;
|
||
let NodeKind::Group { children: paths, clip: false } = &c.kind else { return None };
|
||
(as_drawn(c) && *c.appearance == Appearance::default() && !paths.is_empty()).then_some(())?;
|
||
let (mut paints, mut strokes) = (vec![], vec![]);
|
||
for p in paths {
|
||
as_drawn(p).then_some(())?;
|
||
let (fill, outline) = plain_paint(p)?;
|
||
if bands && fill.is_some() && band_outline(&outline) {
|
||
// A band, or a mark outlined as one, which the reader reads as a band.
|
||
} else if bands && fill.is_some() && !square(p) {
|
||
return None;
|
||
} else {
|
||
strokes.push(outline);
|
||
}
|
||
paints.push(fill);
|
||
}
|
||
let fill = paints.iter().find_map(Clone::clone);
|
||
paints.iter().all(|f| f.is_none() || *f == fill).then_some(())?;
|
||
(line || paints.iter().all(Option::is_some)).then_some(())?;
|
||
let stroke = strokes.first().cloned().flatten();
|
||
strokes.iter().all(|s| *s == stroke).then_some(())?;
|
||
tags.insert(c.id, format!("%_2 {} 0 0 Go", s + first_col));
|
||
}
|
||
seen.iter().all(|s| *s).then_some(tags)
|
||
}
|
||
|
||
/// Whether `stroke`, a path's line and its weight, is the thin black outline Draw Filled Lines
|
||
/// draws around a band, whatever the series' own line.
|
||
pub(crate) fn band_outline(stroke: &Option<(Paint, f64)>) -> bool {
|
||
stroke
|
||
.as_ref()
|
||
.is_some_and(|(paint, width)| *width == FILLED_LINE_OUTLINE_WIDTH && paint.color().is_some_and(|c| c.to_rgb_uncalibrated() == [0.0; 3]))
|
||
}
|
||
|
||
/// Whether path `p` is a square with sides along the page's axes, as a data point's default
|
||
/// marker and a legend swatch are: four straight sides, closed, as wide as it is tall. In a series
|
||
/// with filled lines, every other filled path is a band.
|
||
pub(crate) fn square(p: &Node) -> bool {
|
||
let NodeKind::Path { path, .. } = &p.kind else { return false };
|
||
if path.subpaths.iter().filter(|sp| !sp.anchors.is_empty()).count() != 1 {
|
||
return false;
|
||
}
|
||
let near = |a: f64, b: f64| (a - b).abs() <= EDGE;
|
||
let mut sides = vec![];
|
||
for s in path.to_bezpath().segments() {
|
||
let PathSeg::Line(l) = s else { return false };
|
||
if !(near(l.p0.x, l.p1.x) && near(l.p0.y, l.p1.y)) {
|
||
sides.push(l);
|
||
}
|
||
}
|
||
let [first, _, _, last] = sides.as_slice() else { return false };
|
||
let (x0, x1) = sides.iter().fold((f64::INFINITY, f64::NEG_INFINITY), |(lo, hi), l| (lo.min(l.p0.x), hi.max(l.p0.x)));
|
||
let (y0, y1) = sides.iter().fold((f64::INFINITY, f64::NEG_INFINITY), |(lo, hi), l| (lo.min(l.p0.y), hi.max(l.p0.y)));
|
||
near(last.p1.x, first.p0.x)
|
||
&& near(last.p1.y, first.p0.y)
|
||
&& sides.iter().all(|l| near(l.p0.x, l.p1.x) || near(l.p0.y, l.p1.y))
|
||
&& x1 - x0 > EDGE
|
||
&& near(x1 - x0, y1 - y0)
|
||
}
|
||
|
||
/// Whether `art` draws plot `plot`'s left edge and its bottom edge (the document's y runs down) as
|
||
/// straight lines, each a shown path of one subpath with a plain line ([`plain_paint`]) in a shown
|
||
/// group, as the reader finds the axes.
|
||
fn draws_axes(art: &Node, plot: Rect) -> bool {
|
||
let near = |a: Point, b: Point| (a - b).hypot() <= EDGE;
|
||
let on = |s: &PathSeg, a: Point, b: Point| match s {
|
||
PathSeg::Line(l) => (near(l.p0, a) && near(l.p1, b)) || (near(l.p0, b) && near(l.p1, a)),
|
||
_ => false,
|
||
};
|
||
let (top_left, bottom_left, bottom_right) = (Point::new(plot.x0, plot.y0), Point::new(plot.x0, plot.y1), Point::new(plot.x1, plot.y1));
|
||
let (mut left, mut bottom) = (false, false);
|
||
let mut stack = vec![art];
|
||
while let Some(n) = stack.pop() {
|
||
if !n.visible || n.opacity <= 0.0 || (left && bottom) {
|
||
continue;
|
||
}
|
||
match &n.kind {
|
||
NodeKind::Group { children, clip: false } => stack.extend(children.iter().map(|c| &**c)),
|
||
NodeKind::Path { path, .. } if plain_paint(n).is_some_and(|(_, line)| line.is_some()) => {
|
||
for s in path.to_bezpath().segments() {
|
||
left |= on(&s, top_left, bottom_left);
|
||
bottom |= on(&s, bottom_left, bottom_right);
|
||
}
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
left && bottom
|
||
}
|
||
|
||
/// Graphs built as the graph tools draw them, for the writers' tests.
|
||
#[cfg(test)]
|
||
pub(crate) mod sample {
|
||
use std::sync::Arc;
|
||
|
||
use vectorcraft_color::{Color, Paint};
|
||
use vectorcraft_doc::{Document, GraphKind, GraphSpec, Node, PieSort, TickLength, ValueAxisSide};
|
||
use vectorcraft_geom::{PathData, Point, Rect, shapes};
|
||
|
||
use super::Appearance;
|
||
|
||
/// A graph of kind `kind`: series East and West, categories Q1 to Q3, West blank in Q2, on the
|
||
/// plot 100 100 300 250.
|
||
pub(crate) fn spec(kind: GraphKind) -> GraphSpec {
|
||
let mut g = GraphSpec {
|
||
kind,
|
||
rect: Rect::new(100.0, 100.0, 300.0, 250.0),
|
||
series: vec!["East".into(), "West".into()],
|
||
categories: vec!["Q1".into(), "Q2".into(), "Q3".into()],
|
||
..GraphSpec::default()
|
||
};
|
||
g.set_cells(vec![vec![Some(5.0), Some(3.0)], vec![Some(7.0), None], vec![Some(4.0), Some(6.0)]]);
|
||
g
|
||
}
|
||
|
||
fn path(doc: &mut Document, p: PathData, fill: Paint, stroke: Paint) -> Arc<Node> {
|
||
Arc::new(Node::path(doc.alloc_id(), p, Appearance::basic(fill, stroke, 1.0)))
|
||
}
|
||
|
||
/// Graph `g` drawn as a group: a group of each series' marks (a line graph's series as an unfilled
|
||
/// line, or with filled lines as an outlined band and its markers, the others' as filled
|
||
/// columns), its axes on the plot's left and bottom edges, and a
|
||
/// legend of a swatch for each series; its series groups named after the series.
|
||
pub(crate) fn graph(doc: &mut Document, g: GraphSpec) -> Node {
|
||
let r = g.rect;
|
||
let cells = g.cells();
|
||
let width = cells.first().map_or(0, Vec::len);
|
||
let mut members = vec![];
|
||
let axes = vec![
|
||
path(doc, shapes::line(Point::new(r.x0, r.y0), Point::new(r.x0, r.y1)), Paint::None, Paint::solid(Color::BLACK)),
|
||
path(doc, shapes::line(Point::new(r.x0, r.y1), Point::new(r.x1, r.y1)), Paint::None, Paint::solid(Color::BLACK)),
|
||
];
|
||
members.push(Arc::new(Node::group(doc.alloc_id(), axes)));
|
||
for s in 0..width {
|
||
let gray = Paint::solid(Color::gray(0.2 + 0.3 * s as f32));
|
||
let points: Vec<Point> = cells
|
||
.iter()
|
||
.enumerate()
|
||
.filter_map(|(c, row)| {
|
||
row.get(s).copied().flatten().map(|v| Point::new(r.x0 + 20.0 + 60.0 * c as f64 + 15.0 * s as f64, r.y1 - v * 10.0))
|
||
})
|
||
.collect();
|
||
let marks: Vec<Arc<Node>> = if g.kind == GraphKind::Line && g.filled_lines {
|
||
// A band around the line, as wide as the Line Width, with the thin black outline, and a
|
||
// marker on each point.
|
||
let half = g.filled_line_width() / 2.0;
|
||
let mut bp = kurbo::BezPath::new();
|
||
for (i, p) in points.iter().enumerate() {
|
||
if i == 0 { bp.move_to((p.x, p.y - half)) } else { bp.line_to((p.x, p.y - half)) }
|
||
}
|
||
for p in points.iter().rev() {
|
||
bp.line_to((p.x, p.y + half));
|
||
}
|
||
bp.close_path();
|
||
let band = Node::path(
|
||
doc.alloc_id(),
|
||
PathData::from_bezpath(&bp),
|
||
Appearance::basic(gray.clone(), Paint::solid(Color::BLACK), super::FILLED_LINE_OUTLINE_WIDTH),
|
||
);
|
||
let mut marks = vec![Arc::new(band)];
|
||
marks.extend(points.iter().map(|p| path(doc, shapes::rectangle(Rect::from_center_size(*p, (5.0, 5.0))), gray.clone(), Paint::None)));
|
||
marks
|
||
} else if g.kind == GraphKind::Line {
|
||
let mut bp = kurbo::BezPath::new();
|
||
for (i, p) in points.iter().enumerate() {
|
||
if i == 0 { bp.move_to(*p) } else { bp.line_to(*p) }
|
||
}
|
||
vec![path(doc, PathData::from_bezpath(&bp), Paint::None, gray)]
|
||
} else {
|
||
points.iter().map(|p| path(doc, shapes::rectangle(Rect::new(p.x, p.y, p.x + 10.0, r.y1)), gray.clone(), Paint::None)).collect()
|
||
};
|
||
let mut series = Node::group(doc.alloc_id(), marks);
|
||
series.name = Some(g.series.get(s).cloned().unwrap_or_else(|| format!("Series {}", s + 1)));
|
||
series.extras_mut().series_index = Some(s as u32);
|
||
members.push(Arc::new(series));
|
||
}
|
||
let swatches: Vec<Arc<Node>> = (0..width)
|
||
.map(|s| {
|
||
let y = r.y0 + 12.0 * s as f64;
|
||
path(
|
||
doc,
|
||
shapes::rectangle(Rect::new(r.x1 + 10.0, y, r.x1 + 18.0, y + 8.0)),
|
||
Paint::solid(Color::gray(0.2 + 0.3 * s as f32)),
|
||
Paint::None,
|
||
)
|
||
})
|
||
.collect();
|
||
members.push(Arc::new(Node::group(doc.alloc_id(), swatches)));
|
||
let mut n = Node::group(doc.alloc_id(), members);
|
||
n.extras_mut().graph = Some(Box::new(g));
|
||
n
|
||
}
|
||
|
||
/// A 400 × 300 document holding `g` drawn by [`graph`] on its layer.
|
||
pub(crate) fn document(g: GraphSpec) -> Document {
|
||
let mut doc = Document::new(400.0, 300.0);
|
||
let layer = doc.layers[0].id;
|
||
let n = graph(&mut doc, g);
|
||
doc.insert(Some(layer), usize::MAX, n).unwrap();
|
||
doc
|
||
}
|
||
|
||
/// Graphs whose records read back whole: each type the records give, every setting they keep
|
||
/// changed, labels with parentheses, backslashes and non-ASCII characters, a label of 255 bytes,
|
||
/// a table without labels, and line graphs with filled lines and Line Widths the records give.
|
||
pub(crate) fn kept() -> Vec<(&'static str, Document)> {
|
||
let mut cases = vec![
|
||
("column", document(spec(GraphKind::Column))),
|
||
("stacked column", document(spec(GraphKind::StackedColumn))),
|
||
("line", document(spec(GraphKind::Line))),
|
||
("area", document(spec(GraphKind::Area))),
|
||
];
|
||
let mut g = spec(GraphKind::Column);
|
||
(g.drop_shadow, g.first_row_in_front, g.first_column_in_front, g.legend_across_top) = (true, true, true, true);
|
||
(g.mark_points, g.connect_points, g.edge_to_edge) = (false, false, true);
|
||
(g.column_width, g.cluster_width) = (120.0, 50.0);
|
||
(g.tick_length, g.tick_marks, g.ticks, g.axis_min, g.axis_max) = (TickLength::Full, 3, 4, Some(0.0), Some(20.0));
|
||
(g.right_tick_length, g.right_tick_marks, g.right_ticks, g.right_axis_min, g.right_axis_max) = (TickLength::None, 2, 5, Some(1.0), Some(6.0));
|
||
(g.category_tick_length, g.category_tick_marks, g.ticks_between_labels) = (TickLength::Short, 2, true);
|
||
(g.prefix, g.suffix, g.right_prefix, g.right_suffix) = ("($".into(), "\\)".into(), "é".into(), " u".into());
|
||
cases.push(("settings", document(g)));
|
||
let mut g = spec(GraphKind::Column);
|
||
g.series = vec!["A (1)".into(), "B\\2".into()];
|
||
g.categories = vec![String::new(), "naïve".into(), "a".repeat(255)];
|
||
g.set_cells(vec![vec![Some(1.0 / 3.0), Some(1e-7)], vec![None, Some(2.5)], vec![Some(12.0), None]]);
|
||
cases.push(("labels", document(g)));
|
||
let mut g = spec(GraphKind::Column);
|
||
(g.series, g.categories) = (vec![], vec![]);
|
||
cases.push(("no labels", document(g)));
|
||
let line = |f: &dyn Fn(&mut GraphSpec)| {
|
||
let mut g = spec(GraphKind::Line);
|
||
f(&mut g);
|
||
document(g)
|
||
};
|
||
cases.extend([
|
||
("filled lines", line(&|g| g.filled_lines = true)),
|
||
("filled lines 8 pt wide", line(&|g| (g.filled_lines, g.line_width) = (true, Some(8.0)))),
|
||
("filled lines 100 pt wide", line(&|g| (g.filled_lines, g.line_width) = (true, Some(100.0)))),
|
||
("filled lines 0.01 pt wide", line(&|g| (g.filled_lines, g.line_width) = (true, Some(0.01)))),
|
||
("a Line Width without filled lines", line(&|g| g.line_width = Some(8.0))),
|
||
]);
|
||
cases
|
||
}
|
||
|
||
/// Graphs the records can't give as they are, which are written as their art: the five other
|
||
/// types, settings the reader doesn't keep, a table it can't hold, and art it can't attach the
|
||
/// graph to.
|
||
pub(crate) fn unkept() -> Vec<(&'static str, Document)> {
|
||
let with = |f: &dyn Fn(&mut GraphSpec)| {
|
||
let mut g = spec(GraphKind::Column);
|
||
f(&mut g);
|
||
document(g)
|
||
};
|
||
let mut cases: Vec<(&'static str, Document)> = [GraphKind::Bar, GraphKind::StackedBar, GraphKind::Scatter, GraphKind::Pie, GraphKind::Radar]
|
||
.into_iter()
|
||
.map(|k| (k.id(), document(spec(k))))
|
||
.collect();
|
||
cases.extend([
|
||
("no legend", with(&|g| g.legend = false)),
|
||
("a Line Width past 100 pt", with(&|g| (g.kind, g.filled_lines, g.line_width) = (GraphKind::Line, true, Some(150.0)))),
|
||
("a Line Width under 0.01 pt", with(&|g| (g.kind, g.filled_lines, g.line_width) = (GraphKind::Line, true, Some(0.001)))),
|
||
("filled lines without connected points", with(&|g| (g.kind, g.filled_lines, g.connect_points) = (GraphKind::Line, true, false))),
|
||
(
|
||
"filled lines with series stroked as their outline",
|
||
with(&|g| {
|
||
(g.kind, g.filled_lines) = (GraphKind::Line, true);
|
||
g.series_paints = vec![vectorcraft_doc::SeriesPaint {
|
||
stroke: Some(Paint::solid(Color::BLACK)),
|
||
stroke_width: Some(super::FILLED_LINE_OUTLINE_WIDTH),
|
||
..Default::default()
|
||
}];
|
||
}),
|
||
),
|
||
("a series of another type", with(&|g| g.series_kinds = vec![None, Some(GraphKind::Line)])),
|
||
("a marker design", with(&|g| g.series_markers = vec![Some("Star".into())])),
|
||
("a column design", with(&|g| g.series_columns = vec![Some(Default::default())])),
|
||
("label formatting", with(&|g| g.label_styles.values = Some(Default::default()))),
|
||
("a value axis on both sides", with(&|g| g.value_axis = ValueAxisSide::Both)),
|
||
("a series on the right axis", with(&|g| g.right_series = vec![1])),
|
||
("pie settings", with(&|g| g.pie_sort = PieSort::All)),
|
||
("a manual axis without its values", with(&|g| g.ticks = 4)),
|
||
("values without a tick count", with(&|g| (g.axis_min, g.axis_max) = (Some(0.0), Some(10.0)))),
|
||
("101 divisions", with(&|g| (g.ticks, g.axis_min, g.axis_max) = (101, Some(0.0), Some(101.0)))),
|
||
("too many tick marks", with(&|g| g.tick_marks = 21)),
|
||
("a column width past 1000%", with(&|g| g.column_width = 1001.0)),
|
||
("a long prefix", with(&|g| g.prefix = "0123456789".into())),
|
||
("a line break in a label", with(&|g| g.series[0] = "East\nside".into())),
|
||
("a label of 256 bytes", with(&|g| g.categories[0] = "a".repeat(256))),
|
||
("a value that isn't finite", with(&|g| g.rows[0][0] = f64::NAN)),
|
||
("only blank cells", with(&|g| g.set_cells(vec![vec![None, None]; 3]))),
|
||
("fewer labels than series", with(&|g| g.series.truncate(1))),
|
||
]);
|
||
let drawn = |what: &'static str, f: &dyn Fn(&mut Vec<Arc<Node>>)| {
|
||
let mut doc = Document::new(400.0, 300.0);
|
||
let mut n = graph(&mut doc, spec(GraphKind::Column));
|
||
if let Some(c) = n.children_mut() {
|
||
f(c);
|
||
}
|
||
let layer = doc.layers[0].id;
|
||
doc.insert(Some(layer), usize::MAX, n).unwrap();
|
||
(what, doc)
|
||
};
|
||
cases.extend([
|
||
drawn("a series without its group", &|c| {
|
||
c.remove(2);
|
||
}),
|
||
drawn("no axes", &|c| {
|
||
c.remove(0);
|
||
}),
|
||
drawn("a hidden legend", &|c| {
|
||
if let Some(l) = c.last_mut() {
|
||
Arc::make_mut(l).visible = false;
|
||
}
|
||
}),
|
||
drawn("a series drawn half opaque", &|c| Arc::make_mut(&mut c[1]).opacity = 0.5),
|
||
drawn("a series mark with a gradient", &|c| {
|
||
let g = vectorcraft_color::Gradient::new(
|
||
vectorcraft_color::GradientKind::Linear,
|
||
vec![vectorcraft_color::GradientStop::new(0.0, Color::BLACK), vectorcraft_color::GradientStop::new(1.0, Color::WHITE)],
|
||
);
|
||
let series = Arc::make_mut(&mut c[1]);
|
||
if let Some(marks) = series.children_mut() {
|
||
let mark = Arc::make_mut(&mut marks[0]);
|
||
mark.appearance = Appearance::basic(Paint::Gradient(Box::new(vectorcraft_color::GradientPaint::new(g))), Paint::None, 0.0).into();
|
||
}
|
||
}),
|
||
]);
|
||
cases
|
||
}
|
||
|
||
/// The graphs in `doc`, each with the series index of its members.
|
||
pub(crate) fn graphs(doc: &Document) -> Vec<(GraphSpec, Vec<Option<u32>>)> {
|
||
let mut out = vec![];
|
||
doc.walk(|n| {
|
||
if let Some(g) = n.extras().graph.as_deref() {
|
||
out.push((g.clone(), n.children().map(|c| c.iter().map(|c| c.extras().series_index).collect()).unwrap_or_default()));
|
||
}
|
||
});
|
||
out
|
||
}
|
||
|
||
/// Whether `read` is the graph `written` was: the same data and settings, the plot in the same
|
||
/// place; its series' paint is the art's and its bounds are the art's as read.
|
||
pub(crate) fn same(written: &GraphSpec, read: &GraphSpec) -> bool {
|
||
let near = |a: Rect, b: Rect| (a.x0 - b.x0).abs() + (a.y0 - b.y0).abs() + (a.x1 - b.x1).abs() + (a.y1 - b.y1).abs() < 1e-6;
|
||
let plain = |g: &GraphSpec| GraphSpec {
|
||
rect: Rect::ZERO,
|
||
rows: vec![],
|
||
blanks: vec![],
|
||
series_paints: vec![],
|
||
placed: None,
|
||
placed_art: None,
|
||
series_kinds: vec![],
|
||
..g.clone()
|
||
};
|
||
near(written.rect, read.rect) && written.cells() == read.cells() && plain(written) == plain(read)
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
/// Numbers are written so they read back the same, small and large ones included.
|
||
#[test]
|
||
fn numbers_read_back_as_written() {
|
||
for v in [0.0, 1.0, -2.5, 1.0 / 3.0, 1e-7, 123_456_789_012_345_678.0, f64::MAX, f64::MIN_POSITIVE] {
|
||
assert_eq!(real(v).parse::<f64>().ok(), Some(v), "{v}");
|
||
}
|
||
}
|
||
|
||
/// A graph of `categories` rows of `series` values, drawn by [`sample::graph`].
|
||
fn sized(categories: usize, series: usize) -> Node {
|
||
let mut g = sample::spec(GraphKind::Column);
|
||
(g.series, g.categories) = (vec![], vec![]);
|
||
g.set_cells(vec![vec![Some(1.0); series]; categories]);
|
||
sample::graph(&mut vectorcraft_doc::Document::new(400.0, 300.0), g)
|
||
}
|
||
|
||
/// The table the reader holds: up to 10,000 categories and 256 series; past them, the graph is
|
||
/// its art.
|
||
#[test]
|
||
fn tables_up_to_the_readers_limits_are_written() {
|
||
assert!(records(&sized(MAX_GRAPH_CATEGORIES, 1), Affine::IDENTITY).is_some_and(|r| r.head.contains("%_10000 1 0 0 Gz\n")));
|
||
assert!(records(&sized(MAX_GRAPH_CATEGORIES + 1, 1), Affine::IDENTITY).is_none());
|
||
assert!(records(&sized(1, MAX_GRAPH_SERIES), Affine::IDENTITY).is_some_and(|r| r.tags.len() == MAX_GRAPH_SERIES));
|
||
assert!(records(&sized(1, MAX_GRAPH_SERIES + 1), Affine::IDENTITY).is_none());
|
||
}
|
||
|
||
/// Tick-mark counts of 0, which mean one tick mark as 1 does, are written as 1, the count the
|
||
/// reader reads back.
|
||
#[test]
|
||
fn tick_mark_counts_of_0_are_written_as_1() {
|
||
let mut g = sample::spec(GraphKind::Column);
|
||
(g.tick_marks, g.right_tick_marks, g.category_tick_marks) = (0, 0, 0);
|
||
let n = sample::graph(&mut vectorcraft_doc::Document::new(400.0, 300.0), g);
|
||
let head = records(&n, Affine::IDENTITY).map(|r| r.head).unwrap_or_default();
|
||
let marks: Vec<&str> = head.lines().filter(|l| l.ends_with(" GA")).map(|l| l.split(' ').nth(5).unwrap_or("")).collect();
|
||
assert_eq!(marks, ["1", "1", "1"], "{head}");
|
||
}
|
||
|
||
/// A marker or swatch is a square along the page's axes; a band, a rotated square, a rectangle
|
||
/// of other proportions and an open path are not.
|
||
#[test]
|
||
fn markers_are_squares_and_bands_are_not() {
|
||
use vectorcraft_geom::shapes;
|
||
let node = |p: vectorcraft_geom::PathData| Node::path(NodeId(1), p, Appearance::default());
|
||
assert!(square(&node(shapes::rectangle(Rect::new(10.0, 10.0, 15.0, 15.0)))), "a 5 pt marker");
|
||
assert!(!square(&node(shapes::rectangle(Rect::new(10.0, 10.0, 60.0, 13.0)))), "a band along a level line");
|
||
let mut diamond = kurbo::BezPath::new();
|
||
diamond.move_to((0.0, 5.0));
|
||
diamond.line_to((5.0, 0.0));
|
||
diamond.line_to((10.0, 5.0));
|
||
diamond.line_to((5.0, 10.0));
|
||
diamond.close_path();
|
||
assert!(!square(&node(vectorcraft_geom::PathData::from_bezpath(&diamond))), "a rotated square");
|
||
let mut open = kurbo::BezPath::new();
|
||
open.move_to((0.0, 0.0));
|
||
for p in [(5.0, 0.0), (5.0, 5.0), (0.0, 5.0), (0.0, 1.0)] {
|
||
open.line_to(p);
|
||
}
|
||
assert!(!square(&node(vectorcraft_geom::PathData::from_bezpath(&open))), "an open path");
|
||
}
|
||
|
||
/// A table's cells go fifteen to a record, with one string at most in each.
|
||
#[test]
|
||
fn cells_go_fifteen_to_a_record_with_one_string_each() {
|
||
let mut out = String::new();
|
||
let mut t = Table::new(&mut out);
|
||
t.text("a");
|
||
t.text("b");
|
||
for v in 0..16 {
|
||
t.num(f64::from(v));
|
||
}
|
||
t.finish();
|
||
let records: Vec<&str> = out.lines().collect();
|
||
assert_eq!(records[0], "%_(a) Gc");
|
||
assert_eq!(records[1], "%_(b) 0 1 2 3 4 5 6 7 8 9 10 11 12 13 Gc");
|
||
assert_eq!(records[2], "%_14 15 Gc");
|
||
}
|
||
}
|