IHAGI-c
35c4a428ff
A graph's data can now hold blank cells: an empty CSV cell, a null in
`rows` (any cell that isn't a finite number), the rest of a short row,
or a row that has only a label.
- Columns, bars and stacked segments leave a blank cell out instead of
drawing a zero-height mark.
- Line and scatter graphs break their lines around it and draw no
marker there; the value axis ignores it.
- Area, pie and radar graphs draw it as 0, which is what it adds to
them.
The help pages don't describe blank cells, so this is our own choice:
a cell with no value has nothing to draw, which also matches how a
series with a missing year reads in a report.
In the file a blank cell keeps a 0 in `rows` and is listed in a new
`blanks` field ([category, series] pairs, written only when there are
any). A version that doesn't know blanks ignores the field and reads
the zeros, so files still open there, and files without blanks are
unchanged.
A number in straight quotes is a label, as the help page on graph
labels says (a year as a category name, for one). The CSV reader used
to strip the quotes first and read it as a value. Label columns are now
decided for the whole column: once any row starts with a label, every
row's first cell is its label, so a row with an empty label no longer
shifts its values one place left. The data window writes a header row,
labels that are empty, read as numbers or have spaces around them in
quotes, and blanks as empty cells, so they come back as they were.
graph.setData {} returns blanks in `rows` as null, so the rows it
returns can be edited and sent back. A label-only row keeps its place
with blank values; a row with neither a value nor a label is dropped,
and a first row that is a label followed by empty cells (`Year,,`) is
still read as a header with no series names.
The data grid is built in full for drawing and for the data window, so
it now stops at 10,000 categories of 256 series, which keeps a file
with one very long row from allocating without bound.
Behaviour (quoted labels): Add graph labels and data sets:
https://helpx.adobe.com/illustrator/desktop/automate-visualize-data/visualize-data/add-graph-labels-and-data-sets.html
1320 lines
66 KiB
Rust
1320 lines
66 KiB
Rust
//! Graphs: the nine graph tools and Object → Graph (Type…, Data…).
|
||
//!
|
||
//! A graph is a group carrying a [`GraphSpec`]; its children (axes, labels, one group per series
|
||
//! with that series' legend swatch, like Illustrator's group-selectable series) are generated from
|
||
//! the spec. Editing the data or the type regenerates them in place, keeping any move/scale the
|
||
//! user applied to the graph since it was generated.
|
||
|
||
use std::collections::HashMap;
|
||
use std::sync::Arc;
|
||
|
||
use serde_json::{Value, json};
|
||
use vectorcraft_color::{Color, Paint};
|
||
use vectorcraft_doc::{Appearance, CharStyle, Document, GraphKind, GraphSpec, Justify, Node, NodeId, NodeKind, TextObject};
|
||
use vectorcraft_geom::{Affine, BezPath, PathData, Point, Rect, shapes};
|
||
|
||
use super::typecmd::refresh_bounds;
|
||
use super::*;
|
||
|
||
pub fn specs() -> Vec<CommandSpec> {
|
||
vec![
|
||
cmd!(
|
||
"graph.create",
|
||
"Create Graph",
|
||
[],
|
||
None,
|
||
"{type: column|stackedColumn|bar|stackedBar|line|area|scatter|pie|radar, x, y, width, height, series?: [..], categories?: [..], rows?: [[number|null]], csv?} → {id}; an empty CSV cell or a null is a blank value, a number in straight quotes is a label",
|
||
has_doc,
|
||
create
|
||
),
|
||
cmd!(
|
||
"graph.setData",
|
||
"Data…",
|
||
["Object", "Graph"],
|
||
None,
|
||
"{id?, series?, categories?, rows?, csv?: first row = series labels (first cell empty), then one row per category: label, values…; an empty cell or a null is a blank value, a quoted number a label} replace the graph's data; no data → the current {csv, series, categories, rows}",
|
||
has_selection,
|
||
set_data
|
||
),
|
||
cmd!(
|
||
"graph.setType",
|
||
"Type…",
|
||
["Object", "Graph"],
|
||
None,
|
||
"{id?, type?, columnWidth?: %, clusterWidth?: %, legend?: bool, markPoints?: bool, connectPoints?: bool, edgeToEdge?: bool (line graphs: true runs the lines across the whole plot, false puts the points at the centres of their categories), ticks?: n, axisMin?, axisMax?} change the graph type and options (axisMin and axisMax together override the calculated value axis: exactly that range in `ticks` divisions, 5 when 0); no options → the current ones",
|
||
has_selection,
|
||
set_type
|
||
),
|
||
]
|
||
}
|
||
|
||
// ---------- data ----------
|
||
|
||
/// One CSV cell: its text, and whether it was in straight quotes (a quoted number is a label, not a value).
|
||
struct Cell {
|
||
text: String,
|
||
quoted: bool,
|
||
}
|
||
|
||
impl Cell {
|
||
fn number(&self) -> Option<f64> {
|
||
if self.quoted { None } else { self.text.parse::<f64>().ok().filter(|v| v.is_finite()) }
|
||
}
|
||
}
|
||
|
||
fn parse_csv(csv: &str) -> (Vec<String>, Vec<String>, Vec<Vec<Option<f64>>>) {
|
||
let rows: Vec<Vec<Cell>> = csv
|
||
.lines()
|
||
.map(|l| l.trim_end_matches('\r'))
|
||
.filter(|l| !l.trim().is_empty())
|
||
.map(|l| {
|
||
let sep = if l.contains('\t') { '\t' } else { ',' };
|
||
l.split(sep)
|
||
.map(|c| {
|
||
let c = c.trim();
|
||
let quoted = c.len() >= 2 && c.starts_with('"') && c.ends_with('"');
|
||
Cell { text: c.trim_matches('"').to_string(), quoted }
|
||
})
|
||
.collect()
|
||
})
|
||
.collect();
|
||
let Some(first) = rows.first() else { return (vec![], vec![], vec![]) };
|
||
// A label is quoted or doesn't read as a number; an empty unquoted cell is a blank value.
|
||
let label = |c: &Cell| c.quoted || (c.number().is_none() && !c.text.is_empty());
|
||
// A header row has an empty first cell or a label after it, or is a label followed only by empty cells (`Year,,`).
|
||
// All-empty series names mean no legend.
|
||
let empty = |c: &Cell| c.text.is_empty() && !c.quoted;
|
||
let header = first.first().is_some_and(empty)
|
||
|| first.iter().skip(1).any(label)
|
||
|| (first.len() > 1 && first.first().is_some_and(label) && first.iter().skip(1).all(empty));
|
||
let mut series: Vec<String> = if header { first.iter().skip(1).map(|c| c.text.clone()).collect() } else { vec![] };
|
||
if series.iter().all(String::is_empty) {
|
||
series.clear();
|
||
}
|
||
let data = rows.get(usize::from(header)..).unwrap_or_default();
|
||
// The first column holds the category labels if any row starts with one; then it does for every row, so a
|
||
// row with an empty label doesn't shift its values one place left.
|
||
let labelled = data.iter().any(|r| r.first().is_some_and(label));
|
||
let mut categories = vec![];
|
||
let mut values = vec![];
|
||
for r in data {
|
||
if labelled {
|
||
categories.push(r.first().map(|c| c.text.clone()).unwrap_or_default());
|
||
}
|
||
values.push(r.iter().skip(labelled as usize).map(Cell::number).collect());
|
||
}
|
||
(series, categories, values)
|
||
}
|
||
|
||
fn to_csv(g: &GraphSpec) -> String {
|
||
// Always a header row (empty first cell), so a first data row starting with a blank isn't read as one.
|
||
let cells = g.cells();
|
||
let width = cells.iter().map(Vec::len).max().unwrap_or(0).max(g.series.len());
|
||
let mut out = String::from(",");
|
||
out.push_str(&(0..width).map(|s| g.series.get(s).cloned().unwrap_or_default()).collect::<Vec<_>>().join(","));
|
||
out.push('\n');
|
||
let labelled = !g.categories.is_empty();
|
||
for (i, r) in cells.iter().enumerate() {
|
||
if labelled {
|
||
// An empty label, one that reads as a number or one with spaces around it goes in quotes, so it reads back
|
||
// as the same label.
|
||
let c = g.categories.get(i).map(String::as_str).unwrap_or_default();
|
||
if c.trim().is_empty() || c.trim().parse::<f64>().is_ok() || c != c.trim() {
|
||
out.push_str(&format!("\"{c}\""));
|
||
} else {
|
||
out.push_str(c);
|
||
}
|
||
out.push(',');
|
||
}
|
||
out.push_str(&r.iter().map(|v| v.map(fmt_value).unwrap_or_default()).collect::<Vec<_>>().join(","));
|
||
out.push('\n');
|
||
}
|
||
out
|
||
}
|
||
|
||
fn apply_data(g: &mut GraphSpec, p: &Value) -> bool {
|
||
let mut changed = false;
|
||
if let Some(csv) = str_param(p, "csv") {
|
||
let (s, c, r) = parse_csv(csv);
|
||
g.series = s;
|
||
g.categories = c;
|
||
g.set_cells(r);
|
||
changed = true;
|
||
}
|
||
let strings =
|
||
|v: &Value| v.as_array().map(|a| a.iter().map(|x| x.as_str().map(str::to_string).unwrap_or_else(|| x.to_string())).collect::<Vec<_>>());
|
||
if let Some(s) = p.get("series").and_then(strings) {
|
||
g.series = s;
|
||
changed = true;
|
||
}
|
||
if let Some(c) = p.get("categories").and_then(strings) {
|
||
g.categories = c;
|
||
changed = true;
|
||
}
|
||
if let Some(rows) = p.get("rows").and_then(Value::as_array) {
|
||
// `null` (or anything that isn't a finite number) is a blank cell.
|
||
g.set_cells(
|
||
rows.iter().map(|r| r.as_array().map(|a| a.iter().map(|v| v.as_f64().filter(|v| v.is_finite())).collect()).unwrap_or_default()).collect(),
|
||
);
|
||
changed = true;
|
||
}
|
||
// Drop rows with neither a value nor a label; a label-only row stays, its values blank.
|
||
let mut cells = g.cells();
|
||
let keep: Vec<bool> = (0..cells.len())
|
||
.map(|c| cells.get(c).is_some_and(|r| r.iter().any(Option::is_some)) || g.categories.get(c).is_some_and(|l| !l.is_empty()))
|
||
.collect();
|
||
if keep.contains(&false) || cells.len() < g.rows.len() {
|
||
let mut k = keep.iter();
|
||
cells.retain(|_| k.next().copied().unwrap_or(false));
|
||
let mut k = keep.iter();
|
||
g.categories.retain(|_| k.next().copied().unwrap_or(true));
|
||
g.set_cells(cells);
|
||
}
|
||
changed
|
||
}
|
||
|
||
fn fmt_value(v: f64) -> String {
|
||
if (v - v.round()).abs() < 1e-9 {
|
||
format!("{}", v.round() as i64)
|
||
} else {
|
||
format!("{:.2}", v).trim_end_matches('0').trim_end_matches('.').to_string()
|
||
}
|
||
}
|
||
|
||
// ---------- generation ----------
|
||
|
||
/// Series colours: black, then greys (graphs start in greyscale).
|
||
fn default_series_color(i: usize) -> Color {
|
||
const LEVELS: [f32; 8] = [0.0, 0.55, 0.8, 0.3, 0.68, 0.15, 0.9, 0.42];
|
||
let l = LEVELS[i % LEVELS.len()];
|
||
Color::rgb(l, l, l)
|
||
}
|
||
|
||
fn default_series_paint(i: usize) -> Paint {
|
||
Paint::solid(default_series_color(i))
|
||
}
|
||
|
||
/// Fill and stroke for one generated mark of series `i`. A stored fill is used only where the
|
||
/// generator paints with the series colour (`series_fill`). A stored stroke replaces that part's
|
||
/// own stroke, so a column's stroke stays a stroke and a line's markers do not repaint its line.
|
||
fn series_marks(g: &GraphSpec, i: usize, series_fill: bool, stroke: Paint, width: f64) -> (Paint, Paint, f64) {
|
||
let slot = g.series_paints.get(i);
|
||
let fill = if series_fill { slot.and_then(|p| p.fill.clone()).unwrap_or_else(|| default_series_paint(i)) } else { Paint::None };
|
||
let stroke = slot.and_then(|p| p.stroke.clone()).unwrap_or(stroke);
|
||
let width = if slot.is_some_and(|p| p.stroke.is_some()) { slot.and_then(|p| p.stroke_width).unwrap_or(width) } else { width };
|
||
(fill, stroke, width)
|
||
}
|
||
|
||
const LABEL_SIZE: f64 = 9.0;
|
||
|
||
/// A "nice" axis: (min, max, step).
|
||
fn nice_axis(lo: f64, hi: f64, ticks: usize) -> (f64, f64, f64) {
|
||
let (lo, hi) = if (hi - lo).abs() < 1e-12 { (lo.min(0.0), lo.max(0.0) + 1.0) } else { (lo, hi) };
|
||
let n = if ticks == 0 { 5 } else { ticks.clamp(1, 100) } as f64;
|
||
let raw = (hi - lo) / n;
|
||
let mag = 10f64.powf(raw.log10().floor());
|
||
let step = [1.0, 2.0, 2.5, 5.0, 10.0].iter().map(|m| m * mag).find(|s| *s >= raw - 1e-12).unwrap_or(10.0 * mag);
|
||
((lo / step).floor() * step, (hi / step).ceil() * step, step)
|
||
}
|
||
|
||
/// The value axis: with both `axis_min` and `axis_max` set (Graph Type › Tick Values › Override Calculated Values),
|
||
/// exactly that range split into `ticks` divisions (5 when automatic); otherwise a nice axis around the data, using
|
||
/// whichever bound was given.
|
||
fn value_axis(g: &GraphSpec, lo: f64, hi: f64) -> (f64, f64, f64) {
|
||
match (g.axis_min, g.axis_max) {
|
||
(Some(min), Some(max)) if max > min && (max - min).is_finite() => {
|
||
let n = if g.ticks == 0 { 5 } else { g.ticks.clamp(1, 100) } as f64;
|
||
(min, max, (max - min) / n)
|
||
}
|
||
_ => {
|
||
// An override too wide for f64 (or NaN) gives a non-finite axis, which would reach `clamp` with NaN bounds
|
||
// and panic: fall back to the data, then to 0..1.
|
||
let finite = |(a, b, s): (f64, f64, f64)| a.is_finite() && b.is_finite() && s.is_finite() && b > a && s > 0.0;
|
||
[nice_axis(g.axis_min.unwrap_or(lo), g.axis_max.unwrap_or(hi), g.ticks), nice_axis(lo, hi, g.ticks)]
|
||
.into_iter()
|
||
.find(|&a| finite(a))
|
||
.unwrap_or((0.0, 1.0, 0.2))
|
||
}
|
||
}
|
||
}
|
||
|
||
/// The tick values from `lo` to `hi` every `step`, both ends included: counted, not accumulated, so the last tick
|
||
/// lands on `hi` and a step too small for the range (or not finite) can't loop forever. At most 1000 ticks.
|
||
fn tick_values(lo: f64, hi: f64, step: f64) -> Vec<f64> {
|
||
let n = ((hi - lo) / step).round();
|
||
if !(lo.is_finite() && step.is_finite() && step > 0.0 && n.is_finite() && n >= 0.0) {
|
||
return vec![];
|
||
}
|
||
(0..=(n as usize).min(1000)).map(|i| lo + i as f64 * step).collect()
|
||
}
|
||
|
||
struct Gen<'a> {
|
||
d: &'a mut Document,
|
||
out: Vec<Arc<Node>>,
|
||
}
|
||
|
||
impl Gen<'_> {
|
||
fn path(&mut self, pd: PathData, fill: Paint, stroke: Paint, w: f64) -> Arc<Node> {
|
||
Arc::new(Node::path(self.d.alloc_id(), pd, Appearance::basic(fill, stroke, w)))
|
||
}
|
||
fn line(&mut self, a: Point, b: Point) -> Arc<Node> {
|
||
let mut bp = BezPath::new();
|
||
bp.move_to(a);
|
||
bp.line_to(b);
|
||
self.path(PathData::from_bezpath(&bp), Paint::None, Paint::solid(Color::BLACK), 0.5)
|
||
}
|
||
fn text(&mut self, at: Point, s: &str, justify: Justify) -> Arc<Node> {
|
||
let style = CharStyle { size: LABEL_SIZE, fill: Paint::solid(Color::BLACK), ..CharStyle::default() };
|
||
let mut t = TextObject::point(at, s, style);
|
||
t.para.justify = justify;
|
||
refresh_bounds(&mut t);
|
||
Arc::new(Node::new(self.d.alloc_id(), NodeKind::Text(Box::new(t))))
|
||
}
|
||
fn group(&mut self, name: &str, children: Vec<Arc<Node>>) -> Arc<Node> {
|
||
let mut g = Node::group(self.d.alloc_id(), children);
|
||
g.name = Some(name.into());
|
||
Arc::new(g)
|
||
}
|
||
/// A series group. Empty series are omitted by the caller; the index is stored on the group
|
||
/// so later paint edits find the series without counting siblings.
|
||
fn series(&mut self, name: &str, index: usize, children: Vec<Arc<Node>>) -> Arc<Node> {
|
||
let mut g = Node::group(self.d.alloc_id(), children);
|
||
g.name = Some(name.into());
|
||
g.series_index = u32::try_from(index).ok();
|
||
Arc::new(g)
|
||
}
|
||
}
|
||
|
||
/// The stretches of two or more points between blank cells, which a line connects.
|
||
fn runs(pts: &[Option<Point>]) -> Vec<Vec<Point>> {
|
||
pts.split(Option::is_none).map(|r| r.iter().flatten().copied().collect::<Vec<_>>()).filter(|r| r.len() > 1).collect()
|
||
}
|
||
|
||
fn polyline(pts: &[Point], closed: bool) -> PathData {
|
||
let mut bp = BezPath::new();
|
||
for (i, p) in pts.iter().enumerate() {
|
||
if i == 0 {
|
||
bp.move_to(*p);
|
||
} else {
|
||
bp.line_to(*p);
|
||
}
|
||
}
|
||
if closed {
|
||
bp.close_path();
|
||
}
|
||
PathData::from_bezpath(&bp)
|
||
}
|
||
|
||
fn marker(p: Point, s: f64) -> PathData {
|
||
shapes::rectangle(Rect::from_center_size(p, (s, s)))
|
||
}
|
||
|
||
/// Build the graph's children.
|
||
fn generate(d: &mut Document, g: &GraphSpec) -> Vec<Arc<Node>> {
|
||
let mark = |i: usize, series_fill: bool, stroke: Paint, width: f64| series_marks(g, i, series_fill, stroke, width);
|
||
let mut b = Gen { d, out: vec![] };
|
||
let r = g.rect;
|
||
let nser = g.rows.iter().map(Vec::len).max().unwrap_or(0).max(1);
|
||
let ncat = g.rows.len().max(1);
|
||
let series_label = |i: usize| g.series.get(i).cloned().unwrap_or_default();
|
||
let mut series: Vec<Vec<Arc<Node>>> = vec![vec![]; nser];
|
||
// A blank cell (no value) is `None`: columns, bars and stacked segments leave it out, lines and scatter points
|
||
// break around it and the value axis ignores it. Area, pie and radar draw it as 0, which is what it adds to them.
|
||
let cells = g.cells();
|
||
let cell = |c: usize, s: usize| cells.get(c).and_then(|r| r.get(s)).copied().flatten();
|
||
let val = |c: usize, s: usize| cell(c, s).unwrap_or(0.0);
|
||
let stacked = matches!(g.kind, GraphKind::StackedColumn | GraphKind::StackedBar | GraphKind::Area);
|
||
let horizontal = matches!(g.kind, GraphKind::Bar | GraphKind::StackedBar);
|
||
|
||
match g.kind {
|
||
GraphKind::Pie => {
|
||
// One pie per row, side by side; a wedge per series, clockwise from 12 o'clock.
|
||
let w = r.width() / ncat as f64;
|
||
let rad = (w.min(r.height()) / 2.0 * 0.9).max(1.0);
|
||
for c in 0..ncat {
|
||
let centre = Point::new(r.x0 + w * (c as f64 + 0.5), r.y0 + r.height() / 2.0);
|
||
let total: f64 = (0..nser).map(|s| val(c, s).max(0.0)).sum();
|
||
let mut a0 = -std::f64::consts::FRAC_PI_2;
|
||
for (s, items) in series.iter_mut().enumerate() {
|
||
let v = val(c, s).max(0.0);
|
||
if total <= 0.0 || v <= 0.0 {
|
||
continue;
|
||
}
|
||
let sweep = v / total * std::f64::consts::TAU;
|
||
let mut bp = BezPath::new();
|
||
bp.move_to(centre);
|
||
let arc = vectorcraft_geom::kurbo::Arc::new(centre, (rad, rad), a0, sweep, 0.0);
|
||
bp.line_to(centre + vectorcraft_geom::Vec2::new(a0.cos(), a0.sin()) * rad);
|
||
arc.to_cubic_beziers(0.1, |p1, p2, p| bp.curve_to(p1, p2, p));
|
||
bp.close_path();
|
||
let (fill, stroke, w) = mark(s, true, Paint::solid(Color::WHITE), 0.5);
|
||
let n = b.path(PathData::from_bezpath(&bp), fill, stroke, w);
|
||
items.push(n);
|
||
a0 += sweep;
|
||
}
|
||
if let Some(cat) = g.categories.get(c).filter(|c| !c.is_empty()) {
|
||
let t = b.text(Point::new(centre.x, centre.y + rad + LABEL_SIZE * 1.6), cat, Justify::Center);
|
||
b.out.push(t);
|
||
}
|
||
}
|
||
}
|
||
GraphKind::Radar => {
|
||
let centre = r.center();
|
||
let rad = (r.width().min(r.height()) / 2.0).max(1.0);
|
||
let (lo, hi, step) = value_axis(g, 0.0, g.rows.iter().flatten().copied().fold(0.0, f64::max));
|
||
let at = |c: usize, v: f64| {
|
||
let a = -std::f64::consts::FRAC_PI_2 + std::f64::consts::TAU * c as f64 / ncat as f64;
|
||
centre + vectorcraft_geom::Vec2::new(a.cos(), a.sin()) * (rad * ((v - lo) / (hi - lo)).clamp(0.0, 1.0))
|
||
};
|
||
let mut axes = vec![];
|
||
for c in 0..ncat {
|
||
axes.push(b.line(centre, at(c, hi)));
|
||
if let Some(cat) = g.categories.get(c).filter(|c| !c.is_empty()) {
|
||
let p = at(c, hi) + (at(c, hi) - centre).normalize() * (LABEL_SIZE * 1.2);
|
||
axes.push(b.text(Point::new(p.x, p.y + LABEL_SIZE * 0.35), cat, Justify::Center));
|
||
}
|
||
}
|
||
for v in tick_values(lo, hi, step).into_iter().skip(1) {
|
||
let ring: Vec<Point> = (0..ncat).map(|c| at(c, v)).collect();
|
||
axes.push(b.path(polyline(&ring, true), Paint::None, Paint::solid(Color::rgb(0.6, 0.6, 0.6)), 0.25));
|
||
}
|
||
let ax = b.group("Axes", axes);
|
||
b.out.push(ax);
|
||
for (s, items) in series.iter_mut().enumerate() {
|
||
let pts: Vec<Point> = (0..ncat).map(|c| at(c, val(c, s))).collect();
|
||
if g.connect_points && pts.len() > 1 {
|
||
let (fill, stroke, w) = mark(s, false, default_series_paint(s), 1.0);
|
||
items.push(b.path(polyline(&pts, true), fill, stroke, w));
|
||
}
|
||
if g.mark_points {
|
||
for p in pts {
|
||
let (fill, stroke, w) = mark(s, true, Paint::None, 0.0);
|
||
items.push(b.path(marker(p, 4.0), fill, stroke, w));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
_ => {
|
||
// Value range (stacked graphs stack positives and negatives separately).
|
||
let (mut lo, mut hi) = (0.0f64, 0.0f64);
|
||
let scatter = g.kind == GraphKind::Scatter;
|
||
let (mut xlo, mut xhi) = (f64::MAX, f64::MIN);
|
||
for c in 0..ncat {
|
||
if stacked {
|
||
let pos: f64 = (0..nser).map(|s| val(c, s).max(0.0)).sum();
|
||
let neg: f64 = (0..nser).map(|s| val(c, s).min(0.0)).sum();
|
||
hi = hi.max(pos);
|
||
lo = lo.min(neg);
|
||
} else if scatter {
|
||
for s in (0..nser).step_by(2) {
|
||
if let (Some(y), Some(x)) = (cell(c, s), cell(c, s + 1)) {
|
||
hi = hi.max(y);
|
||
lo = lo.min(y);
|
||
xlo = xlo.min(x);
|
||
xhi = xhi.max(x);
|
||
}
|
||
}
|
||
} else {
|
||
for v in (0..nser).filter_map(|s| cell(c, s)) {
|
||
hi = hi.max(v);
|
||
lo = lo.min(v);
|
||
}
|
||
}
|
||
}
|
||
let (lo, hi, step) = value_axis(g, lo, hi);
|
||
// Value → coordinate along the value axis (y for columns/lines, x for bars).
|
||
let vpos = |v: f64| {
|
||
let t = (v - lo) / (hi - lo);
|
||
if horizontal { r.x0 + t * r.width() } else { r.y1 - t * r.height() }
|
||
};
|
||
let mut axes = vec![];
|
||
// Value axis with ticks and labels.
|
||
for v in tick_values(lo, hi, step) {
|
||
let q = vpos(v);
|
||
if horizontal {
|
||
axes.push(b.line(Point::new(q, r.y1), Point::new(q, r.y1 + 4.0)));
|
||
axes.push(b.text(Point::new(q, r.y1 + 4.0 + LABEL_SIZE * 1.1), &fmt_value(v), Justify::Center));
|
||
} else {
|
||
axes.push(b.line(Point::new(r.x0 - 4.0, q), Point::new(r.x0, q)));
|
||
axes.push(b.text(Point::new(r.x0 - 6.0, q + LABEL_SIZE * 0.35), &fmt_value(v), Justify::Right));
|
||
}
|
||
}
|
||
if horizontal {
|
||
axes.push(b.line(Point::new(r.x0, r.y1), Point::new(r.x1, r.y1)));
|
||
axes.push(b.line(Point::new(vpos(0.0f64.clamp(lo, hi)), r.y0), Point::new(vpos(0.0f64.clamp(lo, hi)), r.y1)));
|
||
} else {
|
||
axes.push(b.line(Point::new(r.x0, r.y0), Point::new(r.x0, r.y1)));
|
||
axes.push(b.line(Point::new(r.x0, vpos(0.0f64.clamp(lo, hi))), Point::new(r.x1, vpos(0.0f64.clamp(lo, hi)))));
|
||
}
|
||
// Category positions.
|
||
let span = if horizontal { r.height() } else { r.width() };
|
||
let cat_w = span / ncat as f64;
|
||
let cat_start = |c: usize| if horizontal { r.y0 + c as f64 * cat_w } else { r.x0 + c as f64 * cat_w };
|
||
// Area bands always span the plot; line graphs only with Edge-to-Edge Lines.
|
||
let points_mode = g.kind == GraphKind::Area || (g.kind == GraphKind::Line && g.edge_to_edge);
|
||
let cat_mid = |c: usize| {
|
||
if points_mode && ncat > 1 { r.x0 + r.width() * c as f64 / (ncat - 1) as f64 } else { cat_start(c) + cat_w / 2.0 }
|
||
};
|
||
if !scatter {
|
||
for c in 0..ncat {
|
||
if let Some(cat) = g.categories.get(c).filter(|c| !c.is_empty()) {
|
||
let t = if horizontal {
|
||
b.text(Point::new(r.x0 - 6.0, cat_mid(c) + LABEL_SIZE * 0.35), cat, Justify::Right)
|
||
} else {
|
||
b.text(Point::new(cat_mid(c), r.y1 + LABEL_SIZE * 1.4), cat, Justify::Center)
|
||
};
|
||
axes.push(t);
|
||
}
|
||
}
|
||
} else {
|
||
// Scatter: a horizontal value axis too.
|
||
let (xl, xh, xs) = nice_axis(if xlo == f64::MAX { 0.0 } else { xlo.min(0.0) }, if xhi == f64::MIN { 1.0 } else { xhi }, g.ticks);
|
||
let mut x = xl;
|
||
while x <= xh + xs * 1e-6 {
|
||
let q = r.x0 + (x - xl) / (xh - xl) * r.width();
|
||
axes.push(b.line(Point::new(q, r.y1), Point::new(q, r.y1 + 4.0)));
|
||
axes.push(b.text(Point::new(q, r.y1 + 4.0 + LABEL_SIZE * 1.1), &fmt_value(x), Justify::Center));
|
||
x += xs;
|
||
}
|
||
for (si, s) in (0..nser).step_by(2).enumerate() {
|
||
let pts: Vec<Option<Point>> = (0..ncat)
|
||
.map(|c| match (cell(c, s), cell(c, s + 1)) {
|
||
(Some(y), Some(x)) => Some(Point::new(r.x0 + (x - xl) / (xh - xl) * r.width(), vpos(y))),
|
||
_ => None,
|
||
})
|
||
.collect();
|
||
if g.connect_points {
|
||
for run in runs(&pts) {
|
||
let (fill, stroke, w) = mark(si, false, default_series_paint(si), 1.0);
|
||
series[si].push(b.path(polyline(&run, false), fill, stroke, w));
|
||
}
|
||
}
|
||
if g.mark_points {
|
||
for p in pts.iter().flatten() {
|
||
let (fill, stroke, w) = mark(si, true, Paint::None, 0.0);
|
||
series[si].push(b.path(marker(*p, 5.0), fill, stroke, w));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
let ax = b.group("Axes", axes);
|
||
b.out.push(ax);
|
||
match g.kind {
|
||
GraphKind::Column | GraphKind::Bar => {
|
||
let cluster = cat_w * (g.cluster_width / 100.0).clamp(0.01, 1.0);
|
||
let slot = cluster / nser as f64;
|
||
let bar = slot * (g.column_width / 100.0).clamp(0.01, 1.0);
|
||
for c in 0..ncat {
|
||
let c0 = cat_start(c) + (cat_w - cluster) / 2.0;
|
||
for (s, items) in series.iter_mut().enumerate() {
|
||
let Some(v) = cell(c, s) else { continue };
|
||
let a = c0 + slot * s as f64 + (slot - bar) / 2.0;
|
||
let (v0, v1) = (vpos(0.0f64.clamp(lo, hi)), vpos(v));
|
||
let rect = if horizontal {
|
||
Rect::new(v0.min(v1), a, v0.max(v1), a + bar)
|
||
} else {
|
||
Rect::new(a, v0.min(v1), a + bar, v0.max(v1))
|
||
};
|
||
let (fill, stroke, w) = mark(s, true, Paint::None, 0.0);
|
||
items.push(b.path(shapes::rectangle(rect), fill, stroke, w));
|
||
}
|
||
}
|
||
}
|
||
GraphKind::StackedColumn | GraphKind::StackedBar => {
|
||
let bar = cat_w * (g.column_width / 100.0).clamp(0.01, 1.0) * (g.cluster_width / 100.0).clamp(0.01, 1.0) * 1.2;
|
||
let bar = bar.min(cat_w);
|
||
for c in 0..ncat {
|
||
let a = cat_start(c) + (cat_w - bar) / 2.0;
|
||
let (mut pos, mut neg) = (0.0, 0.0);
|
||
for (s, items) in series.iter_mut().enumerate() {
|
||
let Some(v) = cell(c, s) else { continue };
|
||
let base = if v >= 0.0 { &mut pos } else { &mut neg };
|
||
let (v0, v1) = (vpos(*base), vpos(*base + v));
|
||
*base += v;
|
||
let rect = if horizontal {
|
||
Rect::new(v0.min(v1), a, v0.max(v1), a + bar)
|
||
} else {
|
||
Rect::new(a, v0.min(v1), a + bar, v0.max(v1))
|
||
};
|
||
let (fill, stroke, w) = mark(s, true, Paint::solid(Color::WHITE), 0.25);
|
||
items.push(b.path(shapes::rectangle(rect), fill, stroke, w));
|
||
}
|
||
}
|
||
}
|
||
GraphKind::Line => {
|
||
for (s, items) in series.iter_mut().enumerate() {
|
||
let pts: Vec<Option<Point>> = (0..ncat).map(|c| cell(c, s).map(|v| Point::new(cat_mid(c), vpos(v)))).collect();
|
||
if g.connect_points {
|
||
for run in runs(&pts) {
|
||
let (fill, stroke, w) = mark(s, false, default_series_paint(s), 1.0);
|
||
items.push(b.path(polyline(&run, false), fill, stroke, w));
|
||
}
|
||
}
|
||
if g.mark_points {
|
||
for p in pts.iter().flatten() {
|
||
let (fill, stroke, w) = mark(s, true, Paint::None, 0.0);
|
||
items.push(b.path(marker(*p, 5.0), fill, stroke, w));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
GraphKind::Area => {
|
||
// Cumulative bands, each from the previous total up to its own.
|
||
let mut below: Vec<f64> = vec![0.0; ncat];
|
||
for (s, items) in series.iter_mut().enumerate() {
|
||
let above: Vec<f64> = (0..ncat).map(|c| below[c] + val(c, s)).collect();
|
||
let mut pts: Vec<Point> = (0..ncat).map(|c| Point::new(cat_mid(c), vpos(above[c]))).collect();
|
||
pts.extend((0..ncat).rev().map(|c| Point::new(cat_mid(c), vpos(below[c]))));
|
||
let (fill, stroke, w) = mark(s, true, Paint::solid(Color::WHITE), 0.25);
|
||
items.push(b.path(polyline(&pts, true), fill, stroke, w));
|
||
below = above;
|
||
}
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
}
|
||
// Legend: a swatch + label per series, right of the plot; the swatch joins its series group.
|
||
let legend_series = if g.kind == GraphKind::Scatter { nser.div_ceil(2) } else { nser };
|
||
let mut labels = vec![];
|
||
if g.legend && !g.series.is_empty() {
|
||
let x = r.x1 + 14.0;
|
||
for (s, items) in series.iter_mut().enumerate().take(legend_series) {
|
||
let label = if g.kind == GraphKind::Scatter { series_label(s * 2) } else { series_label(s) };
|
||
if label.is_empty() {
|
||
continue;
|
||
}
|
||
let y = r.y0 + s as f64 * (LABEL_SIZE * 1.8);
|
||
let (fill, stroke, w) = mark(s, true, Paint::None, 0.0);
|
||
items.push(b.path(shapes::rectangle(Rect::new(x, y, x + 8.0, y + 8.0)), fill, stroke, w));
|
||
labels.push(b.text(Point::new(x + 12.0, y + 7.5), &label, Justify::Left));
|
||
}
|
||
}
|
||
for (s, items) in series.into_iter().enumerate() {
|
||
if items.is_empty() {
|
||
continue;
|
||
}
|
||
let name = g.series.get(s).cloned().filter(|n| !n.is_empty()).unwrap_or_else(|| format!("Series {}", s + 1));
|
||
let grp = b.series(&name, s, items);
|
||
b.out.push(grp);
|
||
}
|
||
if !labels.is_empty() {
|
||
let grp = b.group("Legend", labels);
|
||
b.out.push(grp);
|
||
}
|
||
b.out
|
||
}
|
||
|
||
fn children_bounds(children: &[Arc<Node>]) -> Option<Rect> {
|
||
children.iter().filter_map(|c| c.geometric_bounds()).reduce(|a, b| a.union(b))
|
||
}
|
||
|
||
/// Regenerate graph `id` from `spec` (adjusting the plot rect for any move/scale since the last
|
||
/// generation, which is recorded in the spec's `placed` bounds).
|
||
fn regenerate(d: &mut Document, id: NodeId, mut spec: GraphSpec) -> Result<()> {
|
||
let n = d.node(id).ok_or(EngineError::NoNode(id))?;
|
||
if let (Some(placed), Some(now)) = (n.graph.as_ref().and_then(|g| g.placed), n.children().and_then(|c| children_bounds(c)))
|
||
&& placed.width() > 1e-9
|
||
&& placed.height() > 1e-9
|
||
&& (placed.x0 - now.x0).abs() + (placed.y0 - now.y0).abs() + (placed.x1 - now.x1).abs() + (placed.y1 - now.y1).abs() > 1e-6
|
||
{
|
||
let a = Affine::translate(now.origin().to_vec2())
|
||
* Affine::scale_non_uniform(now.width() / placed.width(), now.height() / placed.height())
|
||
* Affine::translate(-placed.origin().to_vec2());
|
||
spec.rect = a.transform_rect_bbox(spec.rect);
|
||
}
|
||
let children = generate(d, &spec);
|
||
spec.placed = children_bounds(&children);
|
||
let n = d.node_mut(id).ok_or(EngineError::NoNode(id))?;
|
||
if let Some(ch) = n.children_mut() {
|
||
*ch = children;
|
||
}
|
||
n.graph = Some(Box::new(spec));
|
||
Ok(())
|
||
}
|
||
|
||
fn create(s: &mut Session, p: &Value) -> Result<Value> {
|
||
const C: &str = "graph.create";
|
||
let kind =
|
||
str_param(p, "type").map(|t| GraphKind::parse(t).ok_or_else(|| bad(C, format!("unknown graph type `{t}`")))).transpose()?.unwrap_or_default();
|
||
let (x, y) = (f64_req(p, "x", C)?, f64_req(p, "y", C)?);
|
||
let (w, h) = (f64_or(p, "width", 200.0).abs().max(1.0), f64_or(p, "height", 150.0).abs().max(1.0));
|
||
let mut spec = GraphSpec { kind, rect: Rect::new(x, y, x + w, y + h), ..GraphSpec::default() };
|
||
if !apply_data(&mut spec, p) {
|
||
// Starter data so the new graph shows something (edit it with Object → Graph → Data…).
|
||
spec.series = vec!["Series 1".into(), "Series 2".into()];
|
||
spec.categories = vec!["A".into(), "B".into(), "C".into(), "D".into()];
|
||
spec.rows = vec![vec![3.0, 2.0], vec![5.0, 4.0], vec![4.0, 6.0], vec![7.0, 5.0]];
|
||
}
|
||
let parent = s.doc()?.insertion_parent();
|
||
let id = s.edit("Graph", |d, sel| {
|
||
let gid = d.alloc_id();
|
||
let mut g = Node::group(gid, vec![]);
|
||
g.name = Some(format!("{} Graph", kind.label()));
|
||
d.insert(parent, usize::MAX, g)?;
|
||
regenerate(d, gid, spec)?;
|
||
sel.set([gid]);
|
||
Ok(gid)
|
||
})?;
|
||
Ok(json!({ "id": id.0 }))
|
||
}
|
||
|
||
/// The selected graph (or the graph containing the selection).
|
||
fn target(s: &Session, p: &Value, cmd: &str) -> Result<NodeId> {
|
||
let st = s.doc()?;
|
||
let start = id_param(p, "id").into_iter().chain(st.selection.objects.iter().copied());
|
||
for id in start {
|
||
let mut cur = Some(id);
|
||
while let Some(c) = cur {
|
||
if st.doc.node(c).is_some_and(|n| n.graph.is_some()) {
|
||
return Ok(c);
|
||
}
|
||
cur = st.doc.parent_of(c);
|
||
}
|
||
}
|
||
Err(bad(cmd, "select a graph"))
|
||
}
|
||
|
||
fn spec_of(s: &Session, id: NodeId) -> Result<GraphSpec> {
|
||
s.doc()?.doc.node(id).and_then(|n| n.graph.as_deref().cloned()).ok_or(EngineError::NoNode(id))
|
||
}
|
||
|
||
/// Where a node inside a graph's generated series art belongs: the graph, the series group and
|
||
/// the series index stored on that group.
|
||
#[derive(Clone, Copy)]
|
||
struct SeriesRef {
|
||
graph: NodeId,
|
||
group: NodeId,
|
||
index: usize,
|
||
}
|
||
|
||
/// Every node in a graph's series groups (the groups too), found in one pass over the document.
|
||
/// Axes, the legend and groups whose index is past the graph's series (the index comes from the
|
||
/// file) are left out.
|
||
fn series_members(doc: &Document) -> HashMap<NodeId, SeriesRef> {
|
||
let mut out = HashMap::new();
|
||
doc.walk(|n| {
|
||
let Some(spec) = n.graph.as_deref() else { return };
|
||
let count = spec.rows.iter().map(Vec::len).max().unwrap_or(0).max(1);
|
||
for group in n.children().into_iter().flatten() {
|
||
let Some(index) = group.series_index.and_then(|i| usize::try_from(i).ok()).filter(|i| *i < count) else { continue };
|
||
let r = SeriesRef { graph: n.id, group: group.id, index };
|
||
group.walk(&mut |m| {
|
||
out.insert(m.id, r);
|
||
});
|
||
}
|
||
});
|
||
out
|
||
}
|
||
|
||
/// Group Selection on a graph series targets its constituent marks and legend swatch, not a
|
||
/// group-level appearance which the generated art does not inherit. Other ids pass through.
|
||
pub(crate) fn paint_targets(doc: &Document, ids: &[NodeId]) -> Vec<NodeId> {
|
||
let members = series_members(doc);
|
||
if members.is_empty() {
|
||
return ids.to_vec();
|
||
}
|
||
let mut out = Vec::new();
|
||
for id in ids {
|
||
match members.get(id).filter(|r| r.group == *id).and_then(|_| doc.node(*id)) {
|
||
Some(group) => group.walk(&mut |m| {
|
||
if matches!(m.kind, NodeKind::Path { .. }) {
|
||
out.push(m.id);
|
||
}
|
||
}),
|
||
None => out.push(*id),
|
||
}
|
||
}
|
||
out.sort_unstable();
|
||
out.dedup();
|
||
out
|
||
}
|
||
|
||
/// Copy the paint just applied to generated series art into that series' fill or stroke. Called
|
||
/// inside the same document edit, so the visible paint and future regeneration undo together.
|
||
/// Gradients, patterns and swatch links are kept as [`Paint`], not reduced to a solid colour.
|
||
pub(crate) fn capture_series_paints(doc: &mut Document, ids: &[NodeId], fill: bool) {
|
||
let members = series_members(doc);
|
||
if members.is_empty() {
|
||
return;
|
||
}
|
||
let captures: Vec<_> = ids
|
||
.iter()
|
||
.filter_map(|id| {
|
||
let r = members.get(id)?;
|
||
let node = doc.node(*id)?;
|
||
let paint = node.appearance.paint_at(None, fill)?.clone();
|
||
let width = (!fill).then(|| node.appearance.stroke_width());
|
||
Some((r.graph, r.index, paint, width))
|
||
})
|
||
.collect();
|
||
for (graph, index, paint, width) in captures {
|
||
let Some(spec) = doc.node_mut(graph).and_then(|n| n.graph.as_deref_mut()) else { continue };
|
||
// `index` is below the graph's series count (`series_members`).
|
||
if spec.series_paints.len() <= index {
|
||
spec.series_paints.resize(index + 1, vectorcraft_doc::SeriesPaint::default());
|
||
}
|
||
let Some(slot) = spec.series_paints.get_mut(index) else { continue };
|
||
if fill {
|
||
slot.fill = Some(paint);
|
||
} else {
|
||
slot.stroke = Some(paint);
|
||
slot.stroke_width = width;
|
||
}
|
||
}
|
||
}
|
||
|
||
fn set_data(s: &mut Session, p: &Value) -> Result<Value> {
|
||
let id = target(s, p, "graph.setData")?;
|
||
let mut spec = spec_of(s, id)?;
|
||
if !apply_data(&mut spec, p) {
|
||
// Blank cells come back as null, so the rows can be edited and sent back as they are.
|
||
return Ok(json!({ "csv": to_csv(&spec), "series": spec.series, "categories": spec.categories, "rows": spec.cells() }));
|
||
}
|
||
s.edit("Graph Data", |d, _| regenerate(d, id, spec))?;
|
||
Ok(json!({ "id": id.0 }))
|
||
}
|
||
|
||
fn set_type(s: &mut Session, p: &Value) -> Result<Value> {
|
||
const C: &str = "graph.setType";
|
||
let id = target(s, p, C)?;
|
||
let mut spec = spec_of(s, id)?;
|
||
let keys = ["type", "columnWidth", "clusterWidth", "legend", "markPoints", "connectPoints", "edgeToEdge", "ticks", "axisMin", "axisMax"];
|
||
if !keys.iter().any(|k| p.get(*k).is_some()) {
|
||
return Ok(json!({
|
||
"type": spec.kind.id(), "columnWidth": spec.column_width, "clusterWidth": spec.cluster_width, "legend": spec.legend,
|
||
"markPoints": spec.mark_points, "connectPoints": spec.connect_points, "edgeToEdge": spec.edge_to_edge, "ticks": spec.ticks,
|
||
"axisMin": spec.axis_min, "axisMax": spec.axis_max,
|
||
}));
|
||
}
|
||
if let Some(t) = str_param(p, "type") {
|
||
spec.kind = GraphKind::parse(t).ok_or_else(|| bad(C, format!("unknown graph type `{t}`")))?;
|
||
}
|
||
spec.column_width = f64_or(p, "columnWidth", spec.column_width).clamp(1.0, 1000.0);
|
||
spec.cluster_width = f64_or(p, "clusterWidth", spec.cluster_width).clamp(1.0, 100.0);
|
||
spec.legend = bool_or(p, "legend", spec.legend);
|
||
spec.mark_points = bool_or(p, "markPoints", spec.mark_points);
|
||
spec.connect_points = bool_or(p, "connectPoints", spec.connect_points);
|
||
spec.edge_to_edge = bool_or(p, "edgeToEdge", spec.edge_to_edge);
|
||
spec.ticks = p.get("ticks").and_then(Value::as_u64).map_or(spec.ticks, |t| t.min(100) as usize);
|
||
if let Some(v) = p.get("axisMin") {
|
||
spec.axis_min = v.as_f64();
|
||
}
|
||
if let Some(v) = p.get("axisMax") {
|
||
spec.axis_max = v.as_f64();
|
||
}
|
||
let label = format!("{} Graph", spec.kind.label());
|
||
s.edit("Graph Type", |d, _| {
|
||
regenerate(d, id, spec)?;
|
||
if let Some(n) = d.node_mut(id)
|
||
&& n.name.as_deref().is_some_and(|nm| nm.ends_with(" Graph"))
|
||
{
|
||
n.name = Some(label);
|
||
}
|
||
Ok(())
|
||
})?;
|
||
Ok(json!({ "id": id.0 }))
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use serde_json::json;
|
||
use vectorcraft_color::Paint;
|
||
use vectorcraft_doc::{GraphKind, GraphSpec, NodeKind};
|
||
|
||
use crate::{NodeId, Session};
|
||
|
||
fn graph(s: &mut Session, ty: &str) -> NodeId {
|
||
let csv = ",2024,2025\nQ1,3,2\nQ2,5,4\nQ3,-1,6";
|
||
NodeId(
|
||
s.execute("graph.create", &json!({"type": ty, "x": 100, "y": 100, "width": 300, "height": 200, "csv": csv})).unwrap()["id"]
|
||
.as_u64()
|
||
.unwrap(),
|
||
)
|
||
}
|
||
|
||
fn group<'a>(n: &'a vectorcraft_doc::Node, name: &str) -> &'a vectorcraft_doc::Node {
|
||
n.children().unwrap().iter().find(|c| c.name.as_deref() == Some(name)).unwrap_or_else(|| panic!("no {name}"))
|
||
}
|
||
|
||
/// The generated group stored for series `index`, not a sibling that happens to share its name.
|
||
fn series(n: &vectorcraft_doc::Node, index: u32) -> &vectorcraft_doc::Node {
|
||
n.children().unwrap().iter().find(|c| c.series_index == Some(index)).unwrap_or_else(|| panic!("no series {index}"))
|
||
}
|
||
|
||
#[test]
|
||
fn every_graph_type_generates_series_groups() {
|
||
let mut s = Session::new();
|
||
s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap();
|
||
for ty in ["column", "stackedColumn", "bar", "stackedBar", "line", "area", "scatter", "pie", "radar"] {
|
||
let id = graph(&mut s, ty);
|
||
let n = s.doc().unwrap().doc.node(id).unwrap().clone();
|
||
assert!(n.graph.is_some(), "{ty}");
|
||
if ty != "scatter" {
|
||
assert!(!group(&n, "2024").children().unwrap().is_empty(), "{ty}");
|
||
assert!(!group(&n, "2025").children().unwrap().is_empty(), "{ty}");
|
||
}
|
||
assert!(n.geometric_bounds().unwrap().width() > 100.0, "{ty}");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn column_heights_follow_data_and_data_edits_regenerate_in_place() {
|
||
let mut s = Session::new();
|
||
s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap();
|
||
let id = graph(&mut s, "column");
|
||
let heights = |s: &Session| -> Vec<f64> {
|
||
let n = s.doc().unwrap().doc.node(id).unwrap().clone();
|
||
// Bars only (the legend swatch is the 8 × 8 square at the end).
|
||
let g = group(&n, "2025");
|
||
let ch = g.children().unwrap();
|
||
ch[..ch.len() - 1].iter().map(|c| c.geometric_bounds().unwrap().height()).collect()
|
||
};
|
||
let h = heights(&s);
|
||
assert!((h[2] / h[0] - 3.0).abs() < 1e-6, "{h:?}");
|
||
// Move the graph, then change the data: it stays where it was moved.
|
||
s.execute("select.set", &json!({"ids": [id.0]})).unwrap();
|
||
s.execute("object.move", &json!({"dx": 50, "dy": 0})).unwrap();
|
||
let x0 = s.doc().unwrap().doc.node(id).unwrap().geometric_bounds().unwrap().x0;
|
||
let v = s.execute("graph.setData", &json!({})).unwrap();
|
||
assert!(v["csv"].as_str().unwrap().contains("Q2,5,4"));
|
||
s.execute("graph.setData", &json!({"csv": ",2024,2025\nQ1,3,2\nQ2,5,8\nQ3,-1,6"})).unwrap();
|
||
let h2 = heights(&s);
|
||
assert!((h2[1] / h2[0] - 4.0).abs() < 1e-6, "{h2:?}");
|
||
assert!((s.doc().unwrap().doc.node(id).unwrap().geometric_bounds().unwrap().x0 - x0).abs() < 1.0);
|
||
// Type change keeps the data; undo restores the columns.
|
||
s.execute("graph.setType", &json!({"type": "pie"})).unwrap();
|
||
assert_eq!(s.doc().unwrap().doc.node(id).unwrap().graph.as_ref().unwrap().kind, vectorcraft_doc::GraphKind::Pie);
|
||
s.execute("edit.undo", &json!({})).unwrap();
|
||
assert_eq!(s.execute("graph.setType", &json!({})).unwrap()["type"], json!("column"));
|
||
// Selecting a bar inside still targets the graph.
|
||
let n = s.doc().unwrap().doc.node(id).unwrap().clone();
|
||
let bar = group(&n, "2024").children().unwrap()[0].id;
|
||
s.execute("select.set", &json!({"ids": [bar.0]})).unwrap();
|
||
assert!(s.execute("graph.setData", &json!({})).is_ok());
|
||
assert!(matches!(n.kind, NodeKind::Group { .. }));
|
||
}
|
||
|
||
/// The x of every marker of series `index`, left to right.
|
||
fn marker_xs(s: &Session, id: NodeId, index: u32) -> Vec<f64> {
|
||
let n = s.doc().unwrap().doc.node(id).unwrap().clone();
|
||
let mut xs: Vec<f64> = series(&n, index)
|
||
.children()
|
||
.unwrap()
|
||
.iter()
|
||
.map(|c| c.geometric_bounds().unwrap())
|
||
.filter(|b| (b.width() - 5.0).abs() < 1e-6)
|
||
.map(|b| b.center().x)
|
||
.collect();
|
||
xs.sort_by(f64::total_cmp);
|
||
xs
|
||
}
|
||
|
||
#[test]
|
||
fn edge_to_edge_lines_off_puts_line_points_at_category_centres() {
|
||
let mut s = Session::new();
|
||
s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap();
|
||
// 300 pt wide, three categories: centres at 150, 250, 350 (off by default); edges at 100 and 400.
|
||
let id = graph(&mut s, "line");
|
||
assert_eq!(marker_xs(&s, id, 0), vec![150.0, 250.0, 350.0]);
|
||
assert_eq!(s.execute("graph.setType", &json!({})).unwrap()["edgeToEdge"], json!(false));
|
||
s.execute("graph.setType", &json!({"edgeToEdge": true})).unwrap();
|
||
assert_eq!(marker_xs(&s, id, 0), vec![100.0, 250.0, 400.0]);
|
||
// A graph saved before the option existed keeps its edge-to-edge lines.
|
||
let old: GraphSpec = serde_json::from_value(json!({"kind": "line"})).unwrap();
|
||
assert!(old.edge_to_edge);
|
||
}
|
||
|
||
#[test]
|
||
fn radar_graphs_follow_mark_and_connect_data_points() {
|
||
let mut s = Session::new();
|
||
s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap();
|
||
let id = graph(&mut s, "radar");
|
||
let parts = |s: &Session| series(&s.doc().unwrap().doc.node(id).unwrap().clone(), 0).children().unwrap().len();
|
||
// The ring, three markers and the legend swatch.
|
||
assert_eq!(parts(&s), 5);
|
||
s.execute("graph.setType", &json!({"markPoints": false})).unwrap();
|
||
assert_eq!(parts(&s), 2);
|
||
s.execute("graph.setType", &json!({"markPoints": true, "connectPoints": false})).unwrap();
|
||
assert_eq!(parts(&s), 4);
|
||
}
|
||
|
||
#[test]
|
||
fn an_overridden_value_axis_is_used_exactly() {
|
||
let mut s = Session::new();
|
||
s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap();
|
||
let r = s.execute("graph.create", &json!({"type": "column", "x": 20, "y": 20, "width": 170, "height": 74, "series": ["a"], "categories": ["x", "y"], "rows": [[4839], [10488]]})).unwrap();
|
||
let id = NodeId(r["id"].as_u64().unwrap());
|
||
let tallest = |s: &Session| -> f64 {
|
||
let n = s.doc().unwrap().doc.node(id).unwrap().clone();
|
||
let bars = series(&n, 0).children().unwrap();
|
||
bars.iter().map(|c| c.geometric_bounds().unwrap().height()).fold(0.0, f64::max)
|
||
};
|
||
// Calculated: a nice axis (0 to 12500 here), so the 10488 column falls short of 10488 / 12000 of the plot.
|
||
assert!((tallest(&s) - 74.0 * 10488.0 / 12000.0).abs() > 1.0);
|
||
s.execute("graph.setType", &json!({"axisMin": 0, "axisMax": 12000})).unwrap();
|
||
assert!((tallest(&s) - 74.0 * 10488.0 / 12000.0).abs() < 1e-6, "{}", tallest(&s));
|
||
let o = s.execute("graph.setType", &json!({})).unwrap();
|
||
assert_eq!((o["axisMin"].as_f64(), o["axisMax"].as_f64()), (Some(0.0), Some(12000.0)));
|
||
// One bound only keeps the calculated (nice) axis around it.
|
||
s.execute("graph.setType", &json!({"axisMax": null})).unwrap();
|
||
assert!((tallest(&s) - 74.0 * 10488.0 / 12000.0).abs() > 1.0);
|
||
}
|
||
|
||
#[test]
|
||
fn tick_values_end_on_the_maximum_and_never_run_away() {
|
||
// Counted, not accumulated: an offset range keeps its last tick.
|
||
let t = super::tick_values(1e10, 1e10 + 1.0, 0.01);
|
||
assert_eq!(t.len(), 101);
|
||
assert!((t[100] - (1e10 + 1.0)).abs() < 1e-3);
|
||
// A range too wide for f64, or a step too small to move, gives no ticks or a capped list.
|
||
assert!(super::tick_values(-1.7e308, 1.7e308, f64::INFINITY).is_empty());
|
||
assert!(super::tick_values(1e20, 1e20 + 16384.0, 163.84).len() <= 1001);
|
||
assert!(super::tick_values(0.0, 1.0, 0.0).is_empty());
|
||
// An override whose span overflows falls back to the calculated axis instead of hanging.
|
||
let mut s = Session::new();
|
||
s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap();
|
||
graph(&mut s, "column");
|
||
s.execute("graph.setType", &json!({"axisMin": -1.7e308, "axisMax": 1.7e308})).unwrap();
|
||
}
|
||
|
||
#[test]
|
||
fn group_selection_paint_becomes_the_series_colour_and_survives_regeneration() {
|
||
let mut s = Session::new();
|
||
s.execute("file.new", &json!({})).unwrap();
|
||
for ty in GraphKind::ALL {
|
||
let id = graph(&mut s, ty.id());
|
||
let series_id = group(s.doc().unwrap().doc.node(id).unwrap(), "2024").id;
|
||
s.execute("paint.setFill", &json!({"ids": [series_id.0], "color": "#ff0000"})).unwrap();
|
||
let spec = s.doc().unwrap().doc.node(id).unwrap().graph.as_deref().unwrap().clone();
|
||
let restored: GraphSpec = serde_json::from_value(serde_json::to_value(&spec).unwrap()).unwrap();
|
||
assert_eq!(spec, restored);
|
||
let red = Paint::solid(vectorcraft_color::Color::rgb(1.0, 0.0, 0.0));
|
||
assert_eq!(spec.series_paints.first().and_then(|p| p.fill.clone()), Some(red.clone()), "{ty:?}");
|
||
let selected_group = group(s.doc().unwrap().doc.node(id).unwrap(), "2024");
|
||
assert!(selected_group.children().unwrap().iter().all(|n| n.appearance.fill_paint() == red), "{ty:?}");
|
||
s.execute("graph.setData", &json!({"rows": [[2, 3], [4, 5]]})).unwrap();
|
||
s.execute("graph.setType", &json!({"type": "line"})).unwrap();
|
||
let spec = s.doc().unwrap().doc.node(id).unwrap().graph.as_deref().unwrap();
|
||
assert_eq!(spec.series_paints.first().and_then(|p| p.fill.clone()), Some(red.clone()), "{ty:?}");
|
||
let series = group(s.doc().unwrap().doc.node(id).unwrap(), "2024").children().unwrap();
|
||
assert!(series.iter().any(|n| n.appearance.fill_paint() == red), "{ty:?}");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn painting_a_series_is_one_undoable_edit() {
|
||
let mut s = Session::new();
|
||
s.execute("file.new", &json!({})).unwrap();
|
||
let id = graph(&mut s, "column");
|
||
let series_id = group(s.doc().unwrap().doc.node(id).unwrap(), "2024").id;
|
||
s.execute("paint.setFill", &json!({"ids": [series_id.0], "color": "#e8573f"})).unwrap();
|
||
assert_eq!(
|
||
s.doc().unwrap().doc.node(id).unwrap().graph.as_ref().unwrap().series_paints[0].fill.as_ref().and_then(Paint::color).unwrap().to_hex(),
|
||
"#e8573f"
|
||
);
|
||
s.execute("edit.undo", &json!({})).unwrap();
|
||
assert!(s.doc().unwrap().doc.node(id).unwrap().graph.as_ref().unwrap().series_paints.is_empty());
|
||
assert_eq!(
|
||
group(s.doc().unwrap().doc.node(id).unwrap(), "2024").children().unwrap()[0].appearance.fill_paint().color(),
|
||
Some(super::default_series_color(0))
|
||
);
|
||
s.execute("edit.redo", &json!({})).unwrap();
|
||
assert_eq!(
|
||
s.doc().unwrap().doc.node(id).unwrap().graph.as_ref().unwrap().series_paints[0].fill.as_ref().and_then(Paint::color).unwrap().to_hex(),
|
||
"#e8573f"
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn painting_one_bar_sets_the_colour_used_by_the_whole_series_on_rebuild() {
|
||
let mut s = Session::new();
|
||
s.execute("file.new", &json!({})).unwrap();
|
||
let id = graph(&mut s, "column");
|
||
let bar = group(s.doc().unwrap().doc.node(id).unwrap(), "2024").children().unwrap()[0].id;
|
||
s.execute("paint.setFill", &json!({"ids": [bar.0], "color": "#12ab34"})).unwrap();
|
||
s.execute("graph.setData", &json!({"rows": [[1, 2], [3, 4]]})).unwrap();
|
||
let node = s.doc().unwrap().doc.node(id).unwrap();
|
||
let green = vectorcraft_color::Color::rgb(18.0 / 255.0, 171.0 / 255.0, 52.0 / 255.0);
|
||
assert_eq!(node.graph.as_ref().unwrap().series_paints[0].fill.as_ref().and_then(Paint::color), Some(green));
|
||
assert!(group(node, "2024").children().unwrap().iter().all(|n| n.appearance.fill_paint().color() == Some(green)));
|
||
}
|
||
|
||
/// A series index read from a file past the graph's series is not a series: painting its art
|
||
/// paints the art alone and stores nothing (no allocation sized by the file).
|
||
#[test]
|
||
fn a_series_index_past_the_graphs_series_is_ignored() {
|
||
let mut s = Session::new();
|
||
s.execute("file.new", &json!({})).unwrap();
|
||
let id = graph(&mut s, "column");
|
||
let series_id = group(s.doc().unwrap().doc.node(id).unwrap(), "2024").id;
|
||
s.edit("Junk", |d, _| {
|
||
d.node_mut(series_id).unwrap().series_index = Some(u32::MAX);
|
||
Ok(())
|
||
})
|
||
.unwrap();
|
||
let bar = group(s.doc().unwrap().doc.node(id).unwrap(), "2024").children().unwrap()[0].id;
|
||
s.execute("paint.setFill", &json!({"ids": [bar.0, series_id.0], "color": "#12ab34"})).unwrap();
|
||
let node = s.doc().unwrap().doc.node(id).unwrap();
|
||
assert!(node.graph.as_ref().unwrap().series_paints.is_empty());
|
||
assert_eq!(group(node, "2024").children().unwrap()[0].appearance.fill_paint().color().map(|c| c.to_hex()), Some("#12ab34".into()));
|
||
}
|
||
|
||
#[test]
|
||
fn painting_a_line_series_stroke_sets_its_persistent_colour() {
|
||
let mut s = Session::new();
|
||
s.execute("file.new", &json!({})).unwrap();
|
||
let id = graph(&mut s, "line");
|
||
let series_id = group(s.doc().unwrap().doc.node(id).unwrap(), "2024").id;
|
||
s.execute("paint.setStroke", &json!({"ids": [series_id.0], "color": "#3751c8"})).unwrap();
|
||
let blue = vectorcraft_color::Color::rgb(55.0 / 255.0, 81.0 / 255.0, 200.0 / 255.0);
|
||
assert_eq!(
|
||
s.doc().unwrap().doc.node(id).unwrap().graph.as_ref().unwrap().series_paints[0].stroke.as_ref().and_then(Paint::color),
|
||
Some(blue)
|
||
);
|
||
assert!(s.doc().unwrap().doc.node(id).unwrap().graph.as_ref().unwrap().series_paints[0].fill.is_none());
|
||
s.execute("graph.setData", &json!({"rows": [[1, 2], [3, 4]]})).unwrap();
|
||
assert!(
|
||
group(s.doc().unwrap().doc.node(id).unwrap(), "2024")
|
||
.children()
|
||
.unwrap()
|
||
.iter()
|
||
.any(|n| n.appearance.stroke_paint().color() == Some(blue))
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn series_colours_survive_native_save_open_and_export() {
|
||
let mut s = Session::new();
|
||
s.execute("file.new", &json!({})).unwrap();
|
||
let id = graph(&mut s, "column");
|
||
let first = group(s.doc().unwrap().doc.node(id).unwrap(), "2024").id;
|
||
let second = group(s.doc().unwrap().doc.node(id).unwrap(), "2025").id;
|
||
s.execute("paint.setFill", &json!({"ids": [first.0], "color": "#f00"})).unwrap();
|
||
s.execute("paint.setFill", &json!({"ids": [second.0], "color": "#008080"})).unwrap();
|
||
let dir = vectorcraft_testkit::temp_dir("graph-palette");
|
||
let path = dir.join("palette.vectorcraft");
|
||
s.execute("document.save", &json!({"path": path})).unwrap();
|
||
s.execute("document.open", &json!({"path": path})).unwrap();
|
||
let paints = &s.doc().unwrap().doc.node(id).unwrap().graph.as_ref().unwrap().series_paints;
|
||
assert_eq!(paints.iter().map(|p| p.fill.as_ref().and_then(Paint::color).unwrap().to_hex()).collect::<Vec<_>>(), vec!["#ff0000", "#008080"]);
|
||
s.execute("select.set", &json!({"ids": [id.0]})).unwrap();
|
||
s.execute("graph.setData", &json!({"id": id.0, "rows": [[3, 4, 5]]})).unwrap();
|
||
let n = s.doc().unwrap().doc.node(id).unwrap();
|
||
let swatch = group(n, "2025").children().unwrap().last().unwrap();
|
||
assert_eq!(swatch.appearance.fill_paint().color().unwrap().to_hex(), "#008080");
|
||
let third = group(n, "Series 3").children().unwrap().first().unwrap();
|
||
assert_eq!(third.appearance.fill_paint().color().unwrap().to_hex(), "#cccccc");
|
||
let svg = s.execute("document.serialize", &json!({"format": "svg"})).unwrap();
|
||
let svg = svg["text"].as_str().unwrap();
|
||
assert!(svg.contains("#ff0000") && svg.contains("#008080"));
|
||
let png = dir.join("palette.png");
|
||
s.execute("document.export", &json!({"format": "png", "path": png})).unwrap();
|
||
let pixels = image::open(&png).unwrap().to_rgba8();
|
||
assert!(pixels.pixels().any(|p| p.0 == [255, 0, 0, 255]));
|
||
assert!(pixels.pixels().any(|p| p.0 == [0, 128, 128, 255]));
|
||
let old: GraphSpec = serde_json::from_value(json!({"rows": [[1.0]]})).unwrap();
|
||
assert!(old.series_paints.is_empty(), "older files keep the greyscale default");
|
||
}
|
||
|
||
#[test]
|
||
fn a_column_stroke_stays_a_stroke_and_a_marker_fill_does_not_recolour_its_line() {
|
||
let mut s = Session::new();
|
||
s.execute("file.new", &json!({})).unwrap();
|
||
let id = graph(&mut s, "column");
|
||
let series_id = group(s.doc().unwrap().doc.node(id).unwrap(), "2024").id;
|
||
s.execute("paint.setStroke", &json!({"ids": [series_id.0], "color": "#0000ff"})).unwrap();
|
||
s.execute("graph.setData", &json!({"rows": [[1, 2], [3, 4]]})).unwrap();
|
||
let spec = s.doc().unwrap().doc.node(id).unwrap().graph.as_deref().unwrap().clone();
|
||
let blue = Paint::solid(vectorcraft_color::Color::rgb(0.0, 0.0, 1.0));
|
||
assert_eq!(spec.series_paints[0].stroke, Some(blue.clone()));
|
||
assert!(spec.series_paints[0].fill.is_none());
|
||
let bar = &group(s.doc().unwrap().doc.node(id).unwrap(), "2024").children().unwrap()[0];
|
||
assert_eq!(bar.appearance.fill_paint().color(), Some(super::default_series_color(0)));
|
||
assert_eq!(bar.appearance.stroke_paint(), blue);
|
||
|
||
let id = graph(&mut s, "line");
|
||
let marker = group(s.doc().unwrap().doc.node(id).unwrap(), "2024").children().unwrap()[1].id;
|
||
s.execute("paint.setFill", &json!({"ids": [marker.0], "color": "#ff0000"})).unwrap();
|
||
s.execute("graph.setData", &json!({"rows": [[1, 2], [3, 4]]})).unwrap();
|
||
let spec = s.doc().unwrap().doc.node(id).unwrap().graph.as_deref().unwrap().clone();
|
||
assert!(spec.series_paints[0].stroke.is_none());
|
||
let series = group(s.doc().unwrap().doc.node(id).unwrap(), "2024").children().unwrap();
|
||
assert_eq!(series[0].appearance.stroke_paint().color(), Some(super::default_series_color(0)));
|
||
assert_eq!(series[1].appearance.fill_paint().color(), Some(vectorcraft_color::Color::rgb(1.0, 0.0, 0.0)));
|
||
}
|
||
|
||
#[test]
|
||
fn a_gradient_fill_survives_regeneration() {
|
||
let mut s = Session::new();
|
||
s.execute("file.new", &json!({})).unwrap();
|
||
let id = graph(&mut s, "column");
|
||
let series_id = group(s.doc().unwrap().doc.node(id).unwrap(), "2024").id;
|
||
s.execute(
|
||
"paint.setFill",
|
||
&json!({"ids": [series_id.0], "gradient": {"kind": "linear", "stops": [{"offset": 0, "color": "#ff0000"}, {"offset": 1, "color": "#0000ff"}]}}),
|
||
)
|
||
.unwrap();
|
||
s.execute("graph.setData", &json!({"rows": [[2, 3], [4, 5]]})).unwrap();
|
||
let spec = s.doc().unwrap().doc.node(id).unwrap().graph.as_deref().unwrap().clone();
|
||
assert!(matches!(spec.series_paints[0].fill, Some(Paint::Gradient(_))));
|
||
let bar = &group(s.doc().unwrap().doc.node(id).unwrap(), "2024").children().unwrap()[0];
|
||
assert!(matches!(bar.appearance.fill_paint(), Paint::Gradient(_)));
|
||
}
|
||
|
||
#[test]
|
||
fn a_series_named_legend_keeps_its_own_index_and_an_empty_series_is_omitted() {
|
||
let mut s = Session::new();
|
||
s.execute("file.new", &json!({})).unwrap();
|
||
let csv = ",Legend,Axes\nQ1,3,2\nQ2,5,4";
|
||
let id = NodeId(s.execute("graph.create", &json!({"type": "column", "x": 0, "y": 0, "csv": csv})).unwrap()["id"].as_u64().unwrap());
|
||
let legend_id = {
|
||
let n = s.doc().unwrap().doc.node(id).unwrap();
|
||
let legend = series(n, 0);
|
||
assert_eq!(legend.name.as_deref(), Some("Legend"));
|
||
assert!(n.children().unwrap().iter().any(|c| c.name.as_deref() == Some("Legend") && c.series_index.is_none()));
|
||
assert!(n.children().unwrap().iter().any(|c| c.name.as_deref() == Some("Axes") && c.series_index.is_none()));
|
||
legend.id
|
||
};
|
||
s.execute("paint.setFill", &json!({"ids": [legend_id.0], "color": "#ff0000"})).unwrap();
|
||
s.execute("graph.setData", &json!({"csv": csv})).unwrap();
|
||
let n = s.doc().unwrap().doc.node(id).unwrap();
|
||
assert_eq!(n.graph.as_ref().unwrap().series_paints[0].fill.as_ref().and_then(Paint::color).unwrap().to_hex(), "#ff0000");
|
||
assert!(n.graph.as_ref().unwrap().series_paints.get(1).is_none_or(|p| p.fill.is_none()));
|
||
assert_eq!(series(n, 0).children().unwrap()[0].appearance.fill_paint().color().unwrap().to_hex(), "#ff0000");
|
||
assert_eq!(series(n, 1).name.as_deref(), Some("Axes"));
|
||
assert_ne!(series(n, 1).children().unwrap()[0].appearance.fill_paint().color().unwrap().to_hex(), "#ff0000");
|
||
|
||
let id = graph(&mut s, "pie");
|
||
s.execute("graph.setType", &json!({"id": id.0, "legend": false})).unwrap();
|
||
s.execute("graph.setData", &json!({"id": id.0, "csv": ",Keep,Drop\nQ1,4,0\nQ2,2,0"})).unwrap();
|
||
let n = s.doc().unwrap().doc.node(id).unwrap();
|
||
assert!(n.children().unwrap().iter().any(|c| c.name.as_deref() == Some("Keep")));
|
||
assert!(n.children().unwrap().iter().all(|c| c.name.as_deref() != Some("Drop")));
|
||
let keep = group(n, "Keep").id;
|
||
s.execute("paint.setFill", &json!({"ids": [keep.0], "color": "#00ff00"})).unwrap();
|
||
s.execute("graph.setData", &json!({"id": id.0, "rows": [[8, 0], [1, 0]]})).unwrap();
|
||
let n = s.doc().unwrap().doc.node(id).unwrap();
|
||
assert_eq!(group(n, "Keep").series_index, Some(0));
|
||
assert_eq!(n.graph.as_ref().unwrap().series_paints[0].fill.as_ref().and_then(Paint::color).unwrap().to_hex(), "#00ff00");
|
||
assert!(n.children().unwrap().iter().all(|c| c.name.as_deref() != Some("Drop")));
|
||
}
|
||
|
||
#[test]
|
||
fn csv_parsing() {
|
||
let (s, c, r) = super::parse_csv("\t2024\t2025\nQ1\t1\t2\nQ2\t3\t4\n");
|
||
assert_eq!(s, vec!["2024", "2025"]);
|
||
assert_eq!(c, vec!["Q1", "Q2"]);
|
||
assert_eq!(r, vec![vec![Some(1.0), Some(2.0)], vec![Some(3.0), Some(4.0)]]);
|
||
let (s, c, r) = super::parse_csv("1,2\n3,4");
|
||
assert!(s.is_empty() && c.is_empty());
|
||
assert_eq!(r.len(), 2);
|
||
assert_eq!(super::nice_axis(0.0, 7.0, 0), (0.0, 8.0, 2.0));
|
||
}
|
||
|
||
#[test]
|
||
fn empty_cells_are_blank_and_quoted_numbers_are_labels() {
|
||
// Quoted years label the rows; empty and non-numeric cells are blank values, not zeros.
|
||
let (s, c, r) = super::parse_csv(",a,b\n\"2023\",1,\n\"2024\",,x\n\"2025\",3,4");
|
||
assert_eq!(s, vec!["a", "b"]);
|
||
assert_eq!(c, vec!["2023", "2024", "2025"]);
|
||
assert_eq!(r, vec![vec![Some(1.0), None], vec![None, None], vec![Some(3.0), Some(4.0)]]);
|
||
// Back to CSV: blanks stay empty and numeric labels keep their quotes, so it reads back the same.
|
||
let mut g = GraphSpec { series: s, categories: c, ..GraphSpec::default() };
|
||
g.set_cells(r);
|
||
assert_eq!(g.blanks, vec![[0, 1], [1, 0], [1, 1]]);
|
||
let csv = super::to_csv(&g);
|
||
assert!(csv.contains("\"2024\",,"), "{csv}");
|
||
let (s2, c2, r2) = super::parse_csv(&csv);
|
||
assert_eq!((s2, c2, r2), (g.series.clone(), g.categories.clone(), g.cells()));
|
||
}
|
||
|
||
#[test]
|
||
fn a_row_with_an_empty_label_keeps_its_values_in_place() {
|
||
// The label column is the first column of every row once any row has a label.
|
||
let (_, c, r) = super::parse_csv(",a,b\nQ1,1,2\n,3,4");
|
||
assert_eq!(c, vec!["Q1", ""]);
|
||
assert_eq!(r, vec![vec![Some(1.0), Some(2.0)], vec![Some(3.0), Some(4.0)]]);
|
||
// And a data window round trip keeps it (the empty label is written as "").
|
||
let mut g = GraphSpec { series: vec!["a".into(), "b".into()], categories: c, ..GraphSpec::default() };
|
||
g.set_cells(r);
|
||
assert_eq!(super::parse_csv(&super::to_csv(&g)).2, g.cells());
|
||
// Without series or labels, a first row starting with a blank is still data after a round trip.
|
||
let mut g = GraphSpec::default();
|
||
g.set_cells(vec![vec![None, Some(2.0)], vec![Some(3.0), Some(4.0)]]);
|
||
let (s, c, r) = super::parse_csv(&super::to_csv(&g));
|
||
assert!(s.is_empty() && c.is_empty());
|
||
assert_eq!(r, g.cells());
|
||
// A label with spaces around a number stays a label, spaces and all.
|
||
let mut g = GraphSpec { categories: vec!["2024 ".into()], ..GraphSpec::default() };
|
||
g.set_cells(vec![vec![Some(1.0)]]);
|
||
assert_eq!(super::parse_csv(&super::to_csv(&g)).1, vec!["2024 "]);
|
||
}
|
||
|
||
#[test]
|
||
fn blanks_read_back_as_null_and_year_header_rows_still_read_as_headers() {
|
||
let mut s = Session::new();
|
||
s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap();
|
||
let r =
|
||
s.execute("graph.create", &json!({"type": "line", "x": 0, "y": 0, "width": 300, "height": 200, "rows": [[1, null], [2, 3]]})).unwrap();
|
||
let id = NodeId(r["id"].as_u64().unwrap());
|
||
assert_eq!(s.execute("graph.setData", &json!({"id": id.0})).unwrap()["rows"], json!([[1.0, null], [2.0, 3.0]]));
|
||
// A label followed by empty cells is a header with no series names, as before blanks existed.
|
||
let (s, c, r) = super::parse_csv("Year,,\n2023,1,2");
|
||
assert!(s.is_empty());
|
||
assert_eq!(c, Vec::<String>::new());
|
||
assert_eq!(r, vec![vec![Some(2023.0), Some(1.0), Some(2.0)]]);
|
||
}
|
||
|
||
#[test]
|
||
fn a_huge_ragged_grid_is_capped() {
|
||
let g = GraphSpec { rows: vec![vec![0.0; vectorcraft_doc::MAX_GRAPH_SERIES + 10]; 3], ..GraphSpec::default() };
|
||
assert!(g.cells().iter().all(|r| r.len() == vectorcraft_doc::MAX_GRAPH_SERIES));
|
||
}
|
||
|
||
#[test]
|
||
fn a_label_only_row_stays_with_blank_values() {
|
||
let mut s = Session::new();
|
||
s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap();
|
||
let r =
|
||
s.execute("graph.create", &json!({"type": "column", "x": 0, "y": 0, "width": 300, "height": 200, "csv": ",a\nQ1,1\nQ2\nQ3,3"})).unwrap();
|
||
let id = NodeId(r["id"].as_u64().unwrap());
|
||
let spec = s.doc().unwrap().doc.node(id).unwrap().graph.clone().unwrap();
|
||
assert_eq!(spec.categories, vec!["Q1", "Q2", "Q3"]);
|
||
assert_eq!(spec.cells(), vec![vec![Some(1.0)], vec![None], vec![Some(3.0)]]);
|
||
}
|
||
|
||
#[test]
|
||
fn blank_cells_leave_out_their_columns_and_break_lines() {
|
||
let mut s = Session::new();
|
||
s.execute("file.new", &json!({"width": 800, "height": 800})).unwrap();
|
||
let rows = json!([[3, 1], [null, 2], [5, null], [4, 4]]);
|
||
let r = s
|
||
.execute("graph.create", &json!({"type": "column", "x": 100, "y": 100, "width": 400, "height": 200, "series": ["a", "b"], "rows": rows}))
|
||
.unwrap();
|
||
let id = NodeId(r["id"].as_u64().unwrap());
|
||
let count = |s: &Session, index: u32| series(&s.doc().unwrap().doc.node(id).unwrap().clone(), index).children().unwrap().len();
|
||
// Three columns each (one blank), plus the legend swatch.
|
||
assert_eq!((count(&s, 0), count(&s, 1)), (4, 4));
|
||
s.execute("graph.setType", &json!({"type": "stackedColumn"})).unwrap();
|
||
assert_eq!((count(&s, 0), count(&s, 1)), (4, 4));
|
||
// Line: series a is 3, blank, 5, 4. The lone first point has nothing to connect to, so one line (5 to 4), three
|
||
// markers and the legend swatch.
|
||
s.execute("graph.setType", &json!({"type": "line"})).unwrap();
|
||
assert_eq!(count(&s, 0), 1 + 3 + 1);
|
||
// Series b is 1, 2, blank, 4: one line (1 to 2), three markers and the swatch.
|
||
assert_eq!(count(&s, 1), 1 + 3 + 1);
|
||
// A data window round trip keeps the blanks.
|
||
let csv = s.execute("graph.setData", &json!({})).unwrap()["csv"].as_str().unwrap().to_string();
|
||
assert_eq!(csv.lines().nth(2), Some(",2"), "{csv}");
|
||
let spec = s.doc().unwrap().doc.node(id).unwrap().graph.clone().unwrap();
|
||
assert_eq!(spec.cells()[1], vec![None, Some(2.0)]);
|
||
// In the file a blank is a 0 placeholder plus its place in `blanks`, so a version without blanks reads
|
||
// numbers (as zeros); a graph without blanks writes no `blanks` at all.
|
||
let v = serde_json::to_value(&spec).unwrap();
|
||
assert_eq!(v["rows"][1], json!([0.0, 2.0]));
|
||
assert_eq!(v["blanks"], json!([[1, 0], [2, 1]]));
|
||
assert!(serde_json::to_value(GraphSpec::default()).unwrap().get("blanks").is_none());
|
||
}
|
||
}
|