2bc41aeb8602
generate.rs
use super::axis::{LABEL_SIZE, MAX_CATEGORY_TICKS, MAX_TICK_MARKS, one_line, radar_axis, tick_values, value_axis};
use super::columns::{Allowance, ColumnArt, column_art, column_designs};
use super::data::fmt_value;
use super::labels::{
Gen, Role, SHADOW_BUDGET, SHADOW_OPACITY, blank_label, filled_lines_on, label_extra_height, label_shift, label_size, label_width, polyline,
recolour_text, runs, shadow_of,
};
use super::markers::{MARKER_BUDGET, marker_cost, marker_designs};
use super::series::{picks_legend_fill, series_marks, with_series_gradients, with_series_group_opacity, with_series_opacity};
use super::{
Arc, BezPath, Color, Document, GraphKind, GraphSpec, Justify, Node, NodeKind, Paint, PathData, Point, Rect, TickLength, ValueAxisSide, shapes,
};
/// Build the graph's children: with each series' column design (Object › Graph › Column) when the document has it,
/// and with plain columns for all when the designs would draw more than COLUMN_BUDGET objects.
pub(super) fn generate(d: &mut Document, g: &GraphSpec) -> Vec<Arc<Node>> {
let column_looks = column_designs(d, g);
match generate_with(d, g, &column_looks) {
Some(out) => out,
None => generate_with(d, g, &[]).unwrap_or_default(),
}
}
/// [`generate`] with the column designs `column_looks`; `None` when they would draw more than COLUMN_BUDGET objects.
pub(super) fn generate_with(d: &mut Document, g: &GraphSpec, column_looks: &[Option<ColumnArt>]) -> Option<Vec<Arc<Node>>> {
let mut p = Plot::new(d, g, column_looks);
match g.kind {
GraphKind::Pie => p.pie(),
GraphKind::Radar => p.radar(),
_ => p.cartesian(),
}
let labels = p.legend();
p.finish(labels)
}
/// The `s`th entry of a per-series list of optional designs.
fn nth<T>(list: &[Option<T>], s: usize) -> Option<&T> {
list.get(s).and_then(Option::as_ref)
}
/// The data a value range is read from: each series' type, the cells (a blank is `None`), which series use the right
/// axis' own scale, and the number of categories.
struct Values<'a> {
kinds: &'a [GraphKind],
cells: &'a [Vec<Option<f64>>],
on_right: &'a [bool],
ncat: usize,
}
impl Values<'_> {
fn cell(&self, c: usize, s: usize) -> Option<f64> {
self.cells.get(c).and_then(|r| r.get(s)).copied().flatten()
}
fn axis(&self, s: usize) -> usize {
usize::from(self.on_right.get(s).copied().unwrap_or(false))
}
/// The value range per axis (stacked graphs stack positives and negatives separately), and a scatter's x range.
fn range(&self, scatter: bool) -> ([f64; 2], [f64; 2], f64, f64) {
let (mut lo, mut hi) = ([0.0f64; 2], [0.0f64; 2]);
let (mut xlo, mut xhi) = (f64::MAX, f64::MIN);
for c in 0..self.ncat {
if !scatter {
for (a, (lo, hi)) in lo.iter_mut().zip(hi.iter_mut()).enumerate() {
self.extend(c, a, (lo, hi));
}
} else {
for s in (0..self.kinds.len()).step_by(2) {
if let (Some(y), Some(x)) = (self.cell(c, s), self.cell(c, s + 1)) {
hi[0] = hi[0].max(y);
lo[0] = lo[0].min(y);
xlo = xlo.min(x);
xhi = xhi.max(x);
}
}
}
}
(lo, hi, xlo, xhi)
}
/// Widen the range of axis `a` by category `c`'s values.
fn extend(&self, c: usize, a: usize, (lo, hi): (&mut f64, &mut f64)) {
let val = |s: usize| self.cell(c, s).unwrap_or(0.0);
let on = |s: &usize, kinds: &[GraphKind]| self.axis(*s) == a && self.kinds.get(*s).is_some_and(|k| kinds.contains(k));
// Stacked columns (or bars) stack together, and so do areas; other series count one value each.
for stack in [[GraphKind::StackedColumn, GraphKind::StackedBar], [GraphKind::Area, GraphKind::Area]] {
let members = || (0..self.kinds.len()).filter(|s| on(s, &stack));
*hi = hi.max(members().map(|s| val(s).max(0.0)).sum());
*lo = lo.min(members().map(|s| val(s).min(0.0)).sum());
}
let single = |s: &usize| on(s, &[GraphKind::Column, GraphKind::Bar, GraphKind::Line]);
for v in (0..self.kinds.len()).filter(single).filter_map(|s| self.cell(c, s)) {
*hi = hi.max(v);
*lo = lo.min(v);
}
}
}
/// The tick values `g`'s value axes are drawn with while they are calculated from the data (Graph Type › Tick Values
/// without Override Calculated Values): the least value, the greatest and the number of divisions of the left (or
/// only) axis, then of the right axis' own scale, which is the left one's unless Separate Scales gives the series on
/// the right axis a scale of their own. A pie graph has no value axis and gives the axis of a graph without data. A
/// single bound the graph has (only a minimum or only a maximum) is calculated with, as the axis is drawn.
pub fn calculated_axes(g: &GraphSpec) -> [(f64, f64, usize); 2] {
// Adding 0 makes a negative zero, which a nice axis around 0 can start at, a plain 0.
let divisions = |(lo, hi, step): (f64, f64, f64)| (lo + 0.0, hi + 0.0, ((hi - lo) / step).round().clamp(1.0, 100.0) as usize);
// The bounds the axis is calculated with: all but a pair that overrides the calculation.
let partial = |min: Option<f64>, max: Option<f64>| match (min, max) {
(Some(a), Some(b)) if b > a && (b - a).is_finite() => (None, None),
bounds => bounds,
};
let (min, max) = partial(g.axis_min, g.axis_max);
if g.kind == GraphKind::Radar {
let top = g.rows.iter().flatten().copied().fold(0.0, f64::max);
return [divisions(value_axis(g.ticks, min, max, 0.0, top)); 2];
}
let nser = g.rows.iter().map(Vec::len).max().unwrap_or(0).clamp(1, vectorcraft_doc::MAX_GRAPH_SERIES);
let kinds: Vec<GraphKind> = (0..nser).map(|s| g.series_kind(s)).collect();
let (scatter, horizontal) = (g.kind == GraphKind::Scatter, matches!(g.kind, GraphKind::Bar | GraphKind::StackedBar));
let separate = g.separate_scales && g.value_axis == ValueAxisSide::Both && !horizontal && !scatter;
let on_right: Vec<bool> = (0..nser).map(|s| separate && g.right_series.contains(&s)).collect();
let cells = if g.kind == GraphKind::Pie { vec![] } else { g.cells() };
let ncat = g.rows.len().clamp(1, vectorcraft_doc::MAX_GRAPH_CATEGORIES);
let (lo, hi, ..) = Values { kinds: &kinds, cells: &cells, on_right: &on_right, ncat }.range(scatter);
let left = divisions(value_axis(g.ticks, min, max, lo[0], hi[0]));
let used = |right: bool| on_right.contains(&right);
if !used(true) {
return [left; 2];
}
let (right_min, right_max) = partial(g.right_axis_min, g.right_axis_max);
let right = divisions(value_axis(g.right_ticks, right_min, right_max, lo[1], hi[1]));
if used(false) { [left, right] } else { [right; 2] }
}
/// One graph being generated: its data, the nodes drawn so far and what the legend and shadows still need.
struct Plot<'a> {
g: &'a GraphSpec,
b: Gen<'a>,
column_looks: &'a [Option<ColumnArt>],
/// Each series' marker design (Object › Graph › Marker), when the document has it; default squares for all
/// when the designs would draw more than MARKER_BUDGET objects.
designs: Vec<Option<Arc<Node>>>,
r: Rect,
nser: usize,
ncat: usize,
/// The labels' sizes (9 pt unless formatted), which their spacing follows.
vs: f64,
cs: f64,
ls: f64,
/// 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.
cells: Vec<Vec<Option<f64>>>,
/// Each series' own type (Combine different graph types); one type for the whole graph unless a series has its own.
kinds: Vec<GraphKind>,
horizontal: bool,
/// Where the art right of the plot ends (the right value axis' labels), so the legend starts after it.
right_edge: f64,
/// Labels drawn over the series: a pie's Legends in Wedges (in the Legend group) and stacked pies' names.
wedge_labels: Vec<Arc<Node>>,
on_top: Vec<Arc<Node>>,
/// Draw Filled Lines, up to FILLED_LINE_BUDGET data points (the outlines are rebuilt on every change).
filled: bool,
/// Where columns and bars reach (past the plot when their widths are over 100%), so the legend keeps clear.
bars_reach: Option<Rect>,
/// Add Drop Shadow: the columns, bars, lines and wedges to cast one.
shadowed: Vec<(usize, Arc<Node>)>,
series: Vec<Vec<Arc<Node>>>,
}
/// A pie (or the ring of a stacked pie) to draw.
#[derive(Clone, Copy)]
struct Ring {
centre: Point,
rad: f64,
hole: f64,
}
/// The geometry of a plot with axes: the value scales and where the categories sit.
struct Geo {
r: Rect,
horizontal: bool,
ncat: usize,
/// Which series use the right axis' own scale.
on_right: Vec<bool>,
left: (f64, f64, f64),
right: (f64, f64, f64),
cat_w: f64,
label_edges: bool,
left_side: bool,
right_side: bool,
}
impl Geo {
fn axis(&self, s: usize) -> usize {
usize::from(self.on_right.get(s).copied().unwrap_or(false))
}
fn scale(&self, a: usize) -> (f64, f64, f64) {
if a == 1 { self.right } else { self.left }
}
/// Value → coordinate along value axis `a` (y for columns/lines, x for bars).
fn vpos(&self, a: usize, v: f64) -> f64 {
let (lo, hi, _) = self.scale(a);
let t = (v - lo) / (hi - lo);
if self.horizontal { self.r.x0 + t * self.r.width() } else { self.r.y1 - t * self.r.height() }
}
/// That axis' zero (or the end nearest it).
fn zero(&self, a: usize) -> f64 {
let (lo, hi, _) = self.scale(a);
self.vpos(a, 0.0f64.clamp(lo, hi))
}
/// Plot points per unit of value along value axis `a`.
fn per_unit(&self, a: usize) -> f64 {
let (lo, hi, _) = self.scale(a);
(if self.horizontal { self.r.width() } else { self.r.height() }) / (hi - lo)
}
fn cat_start(&self, c: usize) -> f64 {
if self.horizontal { self.r.y0 + c as f64 * self.cat_w } else { self.r.x0 + c as f64 * self.cat_w }
}
fn mid(&self, c: usize, edges: bool) -> f64 {
let r = self.r;
if edges && self.ncat > 1 { r.x0 + r.width() * c as f64 / (self.ncat - 1) as f64 } else { self.cat_start(c) + self.cat_w / 2.0 }
}
fn cat_mid(&self, c: usize) -> f64 {
self.mid(c, self.label_edges)
}
/// The ends of a value tick mark at coordinate `q` of axis `a`.
fn tick_ends(&self, len: TickLength, a: usize, q: f64) -> Option<(Point, Point)> {
let r = self.r;
match (len, self.horizontal, a == 1) {
(TickLength::None, ..) => None,
(TickLength::Short, true, _) => Some((Point::new(q, r.y1), Point::new(q, r.y1 + 4.0))),
(TickLength::Short, false, false) => Some((Point::new(r.x0 - 4.0, q), Point::new(r.x0, q))),
(TickLength::Short, false, true) => Some((Point::new(r.x1, q), Point::new(r.x1 + 4.0, q))),
(TickLength::Full, true, _) => Some((Point::new(q, r.y0), Point::new(q, r.y1))),
(TickLength::Full, false, _) => Some((Point::new(r.x0, q), Point::new(r.x1, q))),
}
}
}
/// How columns (or bars) and stacks share a category's width.
struct Cluster {
/// Columns of one category side by side; stacked columns take one slot of that cluster, or, with no plain
/// columns, a width of their own.
columns: Vec<usize>,
stacks: Vec<usize>,
/// One stack per value axis that has stacked series, each in a slot of its own.
stack_axes: Vec<usize>,
own_width: bool,
/// The widths past 100% make the columns (or clusters) overlap.
col_frac: f64,
clus_frac: f64,
cluster: f64,
slot: f64,
bar: f64,
}
impl Cluster {
/// Where a stack on axis `ax` starts across the category `c` (starting at `c0`), and how wide it is.
fn place(&self, geo: &Geo, c: usize, c0: f64, ax: usize) -> (f64, f64) {
if self.own_width {
// Up to the category's width, or past it when the widths are set past 100%.
let cat_w = geo.cat_w;
let w = (cat_w * self.col_frac * self.clus_frac * 1.2).min(cat_w * (self.col_frac * self.clus_frac).max(1.0));
(geo.cat_start(c) + (cat_w - w) / 2.0, w)
} else {
let i = self.columns.len() + self.stack_axes.iter().position(|a| *a == ax).unwrap_or(0);
(c0 + self.slot * i as f64 + (self.slot - self.bar) / 2.0, self.bar)
}
}
}
/// A column, bar or stacked segment to draw.
struct Bar {
s: usize,
rect: Rect,
value: f64,
/// It grows towards the axis' start.
down: bool,
per_unit: f64,
}
fn bar_rect(horizontal: bool, a: f64, w: f64, v0: f64, v1: f64) -> Rect {
if horizontal { Rect::new(v0.min(v1), a, v0.max(v1), a + w) } else { Rect::new(a, v0.min(v1), a + w, v0.max(v1)) }
}
/// White text on a dark wedge.
pub(super) fn is_dark(fill: &Paint) -> bool {
fill.color().is_some_and(|c| {
let [r, g, b] = c.to_rgb();
0.2126 * r + 0.7152 * g + 0.0722 * b < 0.5
})
}
fn dir(a: f64) -> vectorcraft_geom::Vec2 {
vectorcraft_geom::Vec2::new(a.cos(), a.sin())
}
/// A wedge of `ring` from angle `a0` over `sweep`; a ring segment when the ring has a hole.
fn wedge_path(ring: Ring, a0: f64, sweep: f64) -> BezPath {
let Ring { centre, rad, hole } = ring;
let mut bp = BezPath::new();
let arc = vectorcraft_geom::kurbo::Arc::new(centre, (rad, rad), a0, sweep, 0.0);
if hole > 0.0 {
// A ring segment: out along the outer arc, back along the inner one.
bp.move_to(centre + dir(a0) * rad);
arc.to_cubic_beziers(0.1, |p1, p2, p| bp.curve_to(p1, p2, p));
bp.line_to(centre + dir(a0 + sweep) * hole);
let back = vectorcraft_geom::kurbo::Arc::new(centre, (hole, hole), a0 + sweep, -sweep, 0.0);
back.to_cubic_beziers(0.1, |p1, p2, p| bp.curve_to(p1, p2, p));
} else {
bp.move_to(centre);
bp.line_to(centre + dir(a0) * rad);
arc.to_cubic_beziers(0.1, |p1, p2, p| bp.curve_to(p1, p2, p));
}
bp.close_path();
bp
}
/// The radius of the pie with `total`: one size (Even) or sized by the totals (Ratio, by area).
fn pie_radius(g: &GraphSpec, full: f64, biggest: f64, total: f64) -> f64 {
match g.pie_position {
vectorcraft_doc::PiePosition::Even => full,
_ if biggest > 0.0 && biggest.is_finite() => (full * (total / biggest).sqrt()).max(1.0),
_ => full,
}
}
impl<'a> Plot<'a> {
fn new(d: &'a mut Document, g: &'a GraphSpec, column_looks: &'a [Option<ColumnArt>]) -> Self {
let mut designs = marker_designs(d, g);
if marker_cost(g, &designs) > MARKER_BUDGET {
designs.clear();
}
// The same dimensions `GraphSpec::cells` reads: raw rows can be longer than the grid they are read through.
let nser = g.rows.iter().map(Vec::len).max().unwrap_or(0).clamp(1, vectorcraft_doc::MAX_GRAPH_SERIES);
let kinds: Vec<GraphKind> = (0..nser).map(|s| g.series_kind(s)).collect();
Plot {
g,
b: Gen { d, out: vec![], styles: &g.label_styles, columns: Allowance::new() },
column_looks,
designs,
r: g.rect,
nser,
ncat: g.rows.len().clamp(1, vectorcraft_doc::MAX_GRAPH_CATEGORIES),
vs: label_size(&g.label_styles, Role::Value),
cs: label_size(&g.label_styles, Role::Category),
ls: label_size(&g.label_styles, Role::Legend),
cells: g.cells(),
kinds,
horizontal: matches!(g.kind, GraphKind::Bar | GraphKind::StackedBar),
right_edge: g.rect.x1,
wedge_labels: vec![],
on_top: vec![],
filled: filled_lines_on(g, nser),
bars_reach: None,
shadowed: vec![],
series: vec![vec![]; nser],
}
}
fn cell(&self, c: usize, s: usize) -> Option<f64> {
self.cells.get(c).and_then(|r| r.get(s)).copied().flatten()
}
fn val(&self, c: usize, s: usize) -> f64 {
self.cell(c, s).unwrap_or(0.0)
}
fn kind(&self, s: usize) -> GraphKind {
self.kinds.get(s).copied().unwrap_or(self.g.kind)
}
/// Series drawn as columns or bars, which column designs apply to.
fn columnar(&self, s: usize) -> bool {
matches!(self.kind(s), GraphKind::Column | GraphKind::StackedColumn | GraphKind::Bar | GraphKind::StackedBar)
}
/// The series drawn as `kind`.
fn series_of(&self, kind: GraphKind) -> Vec<usize> {
(0..self.nser).filter(|s| self.kind(*s) == kind).collect()
}
fn mark(&self, i: usize, series_fill: bool, stroke: Paint, width: f64) -> (Paint, Paint, f64) {
series_marks(self.g, i, series_fill, stroke, width)
}
/// The stroke paint and width series `s`'s filled marks and its legend swatch get when the series keeps no stroke
/// of its own: a white line between stacked segments, area bands and pie wedges, none on other marks.
fn mark_stroke(&self, s: usize) -> (Paint, f64) {
match self.kind(s) {
GraphKind::StackedColumn | GraphKind::StackedBar | GraphKind::Area => (Paint::solid(Color::WHITE), 0.25),
GraphKind::Pie => (Paint::solid(Color::WHITE), 0.5),
_ => (Paint::None, 0.0),
}
}
fn series_label(&self, i: usize) -> String {
self.g.series.get(i).cloned().unwrap_or_default()
}
fn push_series(&mut self, s: usize, n: Arc<Node>) {
if let Some(items) = self.series.get_mut(s) {
items.push(n);
}
}
/// Add `n` to series `s` and, for the drop shadow, to the shadowed marks.
fn push_shadowed(&mut self, s: usize, n: Arc<Node>) {
self.shadowed.push((s, n.clone()));
self.push_series(s, n);
}
fn reach(&mut self, rect: Rect) {
self.bars_reach = Some(self.bars_reach.map_or(rect, |r| r.union(rect)));
}
// ---- Pie ----
/// One pie per row, a wedge per series, clockwise from 12 o'clock. Position: side by side at one size
/// (Even) or sized by their totals (Ratio, by area), or stacked on one centre, the largest at the back.
fn pie(&mut self) {
let (g, r, ncat, nser) = (self.g, self.r, self.ncat, self.nser);
let totals: Vec<f64> = (0..ncat).map(|c| (0..nser).map(|s| self.val(c, s).max(0.0)).sum()).collect();
let biggest = totals.iter().copied().fold(0.0, f64::max);
let stacked = g.pie_position == vectorcraft_doc::PiePosition::Stacked;
let w = if stacked { r.width() } else { r.width() / ncat as f64 };
let full = (w.min(r.height()) / 2.0 * 0.9).max(1.0);
let radius = |total: f64| pie_radius(g, full, biggest, total);
let mut pies: Vec<usize> = (0..ncat).collect();
if stacked {
pies.sort_by(|a, b| totals.get(*b).copied().unwrap_or(0.0).total_cmp(&totals.get(*a).copied().unwrap_or(0.0)));
}
// Stacked pies share a centre: each one but the smallest is drawn as the ring outside the next smaller
// one, so a pie never covers another (a pie as big as the next one has no ring and is left out).
let inner: Vec<f64> = if stacked {
(0..pies.len()).map(|k| pies.get(k + 1).map_or(0.0, |c| radius(totals.get(*c).copied().unwrap_or(0.0)))).collect()
} else {
vec![0.0; pies.len()]
};
for (k, c) in pies.into_iter().enumerate() {
let total = totals.get(c).copied().unwrap_or(0.0);
let rad = radius(total);
let hole = inner.get(k).copied().unwrap_or(0.0);
if hole >= rad - 1e-9 {
continue;
}
let centre = if stacked { r.center() } else { Point::new(r.x0 + w * (c as f64 + 0.5), r.y0 + r.height() / 2.0) };
let ring = Ring { centre, rad, hole };
self.pie_wedges(c, ring, total);
self.pie_name(c, ring, stacked);
}
}
/// Sort: data order, largest first in each pie, or the first pie's largest-first order everywhere.
fn pie_order(&self, c: usize) -> Vec<usize> {
let mut o: Vec<usize> = (0..self.nser).collect();
let by = match self.g.pie_sort {
vectorcraft_doc::PieSort::None => return o,
vectorcraft_doc::PieSort::All => c,
vectorcraft_doc::PieSort::First => 0,
};
o.sort_by(|a, b| self.val(by, *b).max(0.0).total_cmp(&self.val(by, *a).max(0.0)));
o
}
fn pie_wedges(&mut self, c: usize, ring: Ring, total: f64) {
let mut a0 = -std::f64::consts::FRAC_PI_2;
for s in self.pie_order(c) {
let v = self.val(c, s).max(0.0);
if total <= 0.0 || v <= 0.0 {
continue;
}
let sweep = v / total * std::f64::consts::TAU;
let bp = wedge_path(ring, a0, sweep);
let (stroke, width) = self.mark_stroke(s);
let (fill, stroke, sw) = self.mark(s, true, stroke, width);
let dark = is_dark(&fill);
let n = self.b.path(PathData::from_bezpath(&bp), fill, stroke, sw);
self.push_shadowed(s, n);
// Legends in Wedges: the series label inside its wedge, centred two thirds of the way out.
if self.g.legend && self.g.pie_legend_in_wedges {
self.wedge_label(s, ring, a0 + sweep / 2.0, dark);
}
a0 += sweep;
}
}
fn wedge_label(&mut self, s: usize, ring: Ring, mid: f64, dark: bool) {
let label = self.series_label(s);
if blank_label(&label) {
return;
}
// Two thirds of the way out (of the ring, for a stacked pie).
let at = ring.centre + dir(mid) * (ring.hole + (ring.rad - ring.hole) * 0.62);
let t = self.b.label(Role::Legend, Point::new(at.x, at.y + self.ls * 0.35), &label, Justify::Center, true);
// White on a dark wedge, unless the legend labels were given a colour of their own.
self.wedge_labels.push(if dark && picks_legend_fill(self.g) { recolour_text(&t, Color::WHITE) } else { t });
}
/// The pie's category name.
fn pie_name(&mut self, c: usize, ring: Ring, stacked: bool) {
let Some(cat) = self.g.categories.get(c).filter(|c| !c.is_empty()) else { return };
let (centre, rad, cs) = (ring.centre, ring.rad, self.cs);
if stacked {
// Just above its own outline, all its lines, and drawn over the pies.
let lines = cat.split('|').count() as f64;
let at = Point::new(centre.x, centre.y - rad - cs * 0.4 - (lines - 1.0) * cs * 1.2);
let t = self.b.label(Role::Category, at, cat, Justify::Center, false);
self.on_top.push(t);
} else {
let t = self.b.label(Role::Category, Point::new(centre.x, centre.y + rad + cs * 1.6), cat, Justify::Center, false);
self.b.out.push(t);
}
}
// ---- Radar ----
fn radar(&mut self) {
let (g, r, ncat, cs) = (self.g, self.r, self.ncat, self.cs);
let centre = r.center();
let rad = (r.width().min(r.height()) / 2.0).max(1.0);
let (lo, hi, step) = radar_axis(g);
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(self.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() * (cs * 1.2);
axes.push(self.b.label(Role::Category, Point::new(p.x, p.y + cs * 0.35), cat, Justify::Center, true));
}
}
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(self.b.ring(polyline(&ring, true)));
}
let ax = self.b.group("Axes", axes);
self.b.out.push(ax);
for s in 0..self.series.len() {
let pts: Vec<Point> = (0..ncat).map(|c| at(c, self.val(c, s))).collect();
if g.connect_points && pts.len() > 1 {
let n = self.b.data_line(g, s, polyline(&pts, true), self.filled);
self.push_shadowed(s, n);
}
if g.mark_points {
for p in pts {
let paint = self.mark(s, true, Paint::None, 0.0);
let n = self.b.marker(nth(&self.designs, s), Rect::from_center_size(p, (4.0, 4.0)), paint);
self.push_series(s, n);
}
}
}
}
// ---- Columns, bars, lines, areas and scatter ----
fn cartesian(&mut self) {
let g = self.g;
let scatter = g.kind == GraphKind::Scatter;
// Separate Scales: with the value axis on both sides, the series assigned to the right axis get a scale
// of their own there (axis 1); every other series, and every series without separate scales, uses axis 0.
let separate = g.separate_scales && g.value_axis == ValueAxisSide::Both && !self.horizontal && !scatter;
let mut on_right = vec![false; self.nser];
if separate {
for i in &g.right_series {
if let Some(x) = on_right.get_mut(*i) {
*x = true;
}
}
}
let mut geo = self.geo(on_right);
let (lo, hi, xlo, xhi) = self.value_range(&geo, scatter);
// An axis with no series of its own shows the other one's scale.
let left = value_axis(g.ticks, g.axis_min, g.axis_max, lo[0], hi[0]);
let used = |a: usize| (0..self.nser).any(|s| geo.axis(s) == a);
let (left, right) = if !separate || !used(1) {
(left, left)
} else {
let right = value_axis(g.right_ticks, g.right_axis_min, g.right_axis_max, lo[1], hi[1]);
if used(0) { (left, right) } else { (right, right) }
};
(geo.left, geo.right) = (left, right);
let mut axes = vec![];
self.value_axes(&geo, &mut axes);
if scatter {
self.scatter(&geo, (xlo, xhi), &mut axes);
} else {
self.category_axis(&geo, &mut axes);
}
let ax = self.b.group("Axes", axes);
self.b.out.push(ax);
self.columns(&geo);
self.areas(&geo);
self.lines(&geo);
}
/// The plot's geometry, its value scales still to come.
fn geo(&self, on_right: Vec<bool>) -> Geo {
let (g, r) = (self.g, self.r);
// Value axes with ticks and labels: along the bottom for bar graphs, else on the chosen sides (the right
// one shows the right scale).
let (left_side, right_side) =
if self.horizontal { (true, false) } else { (g.value_axis != ValueAxisSide::Right, g.value_axis != ValueAxisSide::Left) };
let span = if self.horizontal { r.height() } else { r.width() };
// Area bands always span the plot; lines only with Edge-to-Edge Lines. Category labels sit where every
// series puts its points: at the edges when all of them span the plot, else at the category centres.
let spans = |k: GraphKind| k == GraphKind::Area || (k == GraphKind::Line && g.edge_to_edge);
Geo {
r,
horizontal: self.horizontal,
ncat: self.ncat,
on_right,
left: (0.0, 1.0, 1.0),
right: (0.0, 1.0, 1.0),
cat_w: span / self.ncat as f64,
label_edges: self.kinds.iter().all(|k| spans(*k)),
left_side,
right_side,
}
}
/// The value range per axis (stacked graphs stack positives and negatives separately), and a scatter's x range.
fn value_range(&self, geo: &Geo, scatter: bool) -> ([f64; 2], [f64; 2], f64, f64) {
Values { kinds: &self.kinds, cells: &self.cells, on_right: &geo.on_right, ncat: self.ncat }.range(scatter)
}
/// The value axes with ticks and labels, the legend's start after them, and the axis lines.
fn value_axes(&mut self, geo: &Geo, axes: &mut Vec<Arc<Node>>) {
let r = self.r;
if geo.left_side {
let (lo, hi, step) = geo.left;
for v in tick_values(lo, hi, step) {
self.value_tick(geo, axes, 0, v, (step, hi));
}
}
if geo.right_side {
let (lo, hi, step) = geo.right;
for v in tick_values(lo, hi, step) {
self.value_tick(geo, axes, 1, v, (step, hi));
}
}
// The legend starts after the value labels right of the plot: the right axis' (14 points on), or a bar
// graph's last bottom label running past the plot (6 points on; a short number stays within the gap).
for t in axes.iter() {
if matches!(t.kind, NodeKind::Text(_))
&& let Some(bb) = t.geometric_bounds()
&& bb.x1 > r.x1
{
self.right_edge = self.right_edge.max(if bb.x0 > r.x1 { bb.x1 } else { bb.x1 - 8.0 });
}
}
if geo.horizontal {
axes.push(self.b.line(Point::new(r.x0, r.y1), Point::new(r.x1, r.y1)));
axes.push(self.b.line(Point::new(geo.zero(0), r.y0), Point::new(geo.zero(0), r.y1)));
} else {
if geo.left_side {
axes.push(self.b.line(Point::new(r.x0, r.y0), Point::new(r.x0, r.y1)));
}
if geo.right_side {
axes.push(self.b.line(Point::new(r.x1, r.y0), Point::new(r.x1, r.y1)));
}
axes.push(self.b.line(Point::new(r.x0, geo.zero(0)), Point::new(r.x1, geo.zero(0))));
// The right scale's zero, where its columns start, when it isn't the left one's.
if (geo.zero(1) - geo.zero(0)).abs() > 1e-9 {
axes.push(self.b.line(Point::new(r.x0, geo.zero(1)), Point::new(r.x1, geo.zero(1))));
}
}
}
/// Each label's tick mark, then the extra tick marks of its division (Tick Marks per division).
fn value_tick(&mut self, geo: &Geo, axes: &mut Vec<Arc<Node>>, a: usize, v: f64, (step, hi): (f64, f64)) {
let g = self.g;
let (len, marks) = if a == 1 { (g.right_tick_length, g.right_tick_marks) } else { (g.tick_length, g.tick_marks) };
let n = marks.clamp(1, MAX_TICK_MARKS);
for k in 0..n {
let w = v + step * k as f64 / n as f64;
if k > 0 && w >= hi - step * 1e-9 {
break;
}
let q = geo.vpos(a, w);
// A full-length tick on the zero line, or repeating the left side's on one shared scale, adds nothing.
let repeat = a == 1 && geo.left_side && g.tick_length == TickLength::Full && geo.right == geo.left;
let len = if len == TickLength::Full && ((q - geo.zero(a)).abs() < 1e-9 || repeat) { TickLength::None } else { len };
if let Some((p0, p1)) = geo.tick_ends(len, a, q) {
axes.push(self.b.line(p0, p1));
}
if k == 0 {
axes.push(self.value_label(geo, a, q, v));
}
}
}
/// The label after a tick mark: with the Add Labels text of its axis, kept to one short line whatever the file holds.
fn value_label(&mut self, geo: &Geo, a: usize, q: f64, v: f64) -> Arc<Node> {
let (r, vs) = (self.r, self.vs);
let (prefix, suffix) = if a == 1 { (&self.g.right_prefix, &self.g.right_suffix) } else { (&self.g.prefix, &self.g.suffix) };
let label = format!("{}{}{}", one_line(prefix), fmt_value(v), one_line(suffix));
if geo.horizontal {
self.b.text(Role::Value, Point::new(q, r.y1 + 4.0 + vs * 1.1), &label, Justify::Center)
} else if a == 1 {
self.b.text(Role::Value, Point::new(r.x1 + 6.0, q + vs * 0.35), &label, Justify::Left)
} else {
self.b.text(Role::Value, Point::new(r.x0 - 6.0, q + vs * 0.35), &label, Justify::Right)
}
}
/// Category labels and tick marks.
fn category_axis(&mut self, geo: &Geo, axes: &mut Vec<Arc<Node>>) {
let (r, cs) = (self.r, self.cs);
for c in 0..self.ncat {
if let Some(cat) = self.g.categories.get(c).filter(|c| !c.is_empty()) {
let t = if geo.horizontal {
self.b.label(Role::Category, Point::new(r.x0 - 6.0, geo.cat_mid(c) + cs * 0.35), cat, Justify::Right, true)
} else {
self.b.label(Role::Category, Point::new(geo.cat_mid(c), r.y1 + cs * 1.4), cat, Justify::Center, false)
};
axes.push(t);
}
}
// Category tick marks (none by default): at the labels, or between them (at the category edges),
// with the extra tick marks of each division between those.
let len = self.g.category_tick_length;
if len == TickLength::None {
return;
}
let at = self.category_tick_positions(geo);
// A full-length tick on a drawn axis line adds nothing.
let on_axis_line = |q: f64| {
if geo.horizontal {
(q - r.y1).abs() < 1e-9
} else {
((q - r.x0).abs() < 1e-9 && geo.left_side) || ((q - r.x1).abs() < 1e-9 && geo.right_side)
}
};
for q in at.into_iter().take(MAX_CATEGORY_TICKS) {
if len == TickLength::Full && on_axis_line(q) {
continue;
}
let (p0, p1) = match (len, geo.horizontal) {
(TickLength::Full, false) => (Point::new(q, r.y0), Point::new(q, r.y1)),
(TickLength::Full, true) => (Point::new(r.x0, q), Point::new(r.x1, q)),
(_, false) => (Point::new(q, r.y1), Point::new(q, r.y1 + 4.0)),
(_, true) => (Point::new(r.x0 - 4.0, q), Point::new(r.x0, q)),
};
axes.push(self.b.line(p0, p1));
}
}
/// Where the category tick marks go: at the labels, or between them, each division with its extra marks.
fn category_tick_positions(&self, geo: &Geo) -> Vec<f64> {
let shown = self.ncat.min(MAX_CATEGORY_TICKS);
let base: Vec<f64> = match (self.g.ticks_between_labels, geo.label_edges) {
// Labels at the plot's edges: halfway between neighbouring labels.
(true, true) => (1..shown).map(|c| (geo.cat_mid(c - 1) + geo.cat_mid(c)) / 2.0).collect(),
(true, false) => (0..=shown).map(|c| geo.cat_start(c)).collect(),
(false, _) => (0..shown).map(|c| geo.cat_mid(c)).collect(),
};
// Fewer per division on a long axis, so the cap still ticks all of it.
let n = self.g.category_tick_marks.clamp(1, MAX_TICK_MARKS).min(MAX_CATEGORY_TICKS / base.len().max(1)).max(1);
base.iter()
.enumerate()
.flat_map(|(i, q)| {
let next = base.get(i + 1).copied();
(0..n).filter_map(move |k| if k == 0 { Some(*q) } else { next.map(|x| q + (x - q) * k as f64 / n as f64) })
})
.collect()
}
/// Scatter: a horizontal value axis too, and the series' points.
fn scatter(&mut self, geo: &Geo, (xlo, xhi): (f64, f64), axes: &mut Vec<Arc<Node>>) {
let (g, r, vs) = (self.g, self.r, self.vs);
// Like the value axis: finite, and a counted (capped) list of ticks, so data near f64::MAX can't loop forever.
let x_lo = if xlo == f64::MAX { 0.0 } else { xlo.min(0.0) };
let x_hi = if xhi == f64::MIN { 1.0 } else { xhi };
let (xl, xh, xs) = value_axis(g.ticks, None, None, x_lo, x_hi);
for x in tick_values(xl, xh, xs) {
let q = r.x0 + (x - xl) / (xh - xl) * r.width();
axes.push(self.b.line(Point::new(q, r.y1), Point::new(q, r.y1 + 4.0)));
axes.push(self.b.text(Role::Value, Point::new(q, r.y1 + 4.0 + vs * 1.1), &fmt_value(x), Justify::Center));
}
for (si, s) in (0..self.nser).step_by(2).enumerate() {
let pts: Vec<Option<Point>> = (0..self.ncat)
.map(|c| match (self.cell(c, s), self.cell(c, s + 1)) {
(Some(y), Some(x)) => Some(Point::new(r.x0 + (x - xl) / (xh - xl) * r.width(), geo.vpos(0, y))),
_ => None,
})
.collect();
if g.connect_points {
for run in runs(&pts) {
let n = self.b.data_line(g, si, polyline(&run, false), self.filled);
self.shadowed.push((si, n.clone()));
self.series[si].push(n);
}
}
self.point_markers(si, &pts);
}
}
/// A marker on each point of series `s`, when Mark Data Points is on.
fn point_markers(&mut self, s: usize, pts: &[Option<Point>]) {
if !self.g.mark_points {
return;
}
for p in pts.iter().flatten() {
let paint = self.mark(s, true, Paint::None, 0.0);
let n = self.b.marker(nth(&self.designs, s), Rect::from_center_size(*p, (5.0, 5.0)), paint);
self.push_series(s, n);
}
}
/// A column, bar or stacked segment: with its column design when it has one (which casts no shadow), else a plain
/// rectangle in `paint`, shadowed when `shadow`.
fn bar_node(&mut self, bar: Bar, paint: (Paint, Paint, f64), shadow: bool) -> Arc<Node> {
let Bar { s, rect, value, down, per_unit } = bar;
self.reach(rect);
let horizontal = self.horizontal;
let art = nth(self.column_looks, s).and_then(|c| column_art(self.b.d, c, (rect, value), (horizontal, down), per_unit, &mut self.b.columns));
match art {
Some(n) => {
// A design can reach past its column (Uniformly Scaled), so the legend keeps clear of it too.
if let Some(art) = n.geometric_bounds() {
self.reach(art);
}
n
}
None => {
let (fill, stroke, w) = paint;
let n = self.b.path(shapes::rectangle(rect), fill, stroke, w);
if shadow {
self.shadowed.push((s, n.clone()));
}
n
}
}
}
/// Columns (or bars) of one category side by side, and the stacks.
fn columns(&mut self, geo: &Geo) {
let g = self.g;
let nser = self.nser;
let columns: Vec<usize> = (0..nser).filter(|s| matches!(self.kind(*s), GraphKind::Column | GraphKind::Bar)).collect();
let stacks: Vec<usize> = (0..nser).filter(|s| matches!(self.kind(*s), GraphKind::StackedColumn | GraphKind::StackedBar)).collect();
let stack_axes: Vec<usize> = (0..2).filter(|a| stacks.iter().any(|s| geo.axis(*s) == *a)).collect();
let col_frac = (g.column_width / 100.0).clamp(0.01, 10.0);
let clus_frac = (g.cluster_width / 100.0).clamp(0.01, 10.0);
let cluster = geo.cat_w * (g.cluster_width / 100.0).clamp(0.01, 10.0);
let slot = cluster / (columns.len() + stack_axes.len()).max(1) as f64;
let cl = Cluster {
own_width: columns.is_empty() && stack_axes.len() < 2,
columns,
stacks,
stack_axes,
col_frac,
clus_frac,
cluster,
slot,
bar: slot * col_frac,
};
// First Row in Front: the first category drawn last, over the next.
let cats: Vec<usize> = if g.first_row_in_front { (0..self.ncat).rev().collect() } else { (0..self.ncat).collect() };
for c in cats {
let c0 = geo.cat_start(c) + (geo.cat_w - cl.cluster) / 2.0;
self.cluster_columns(geo, &cl, c, c0);
self.cluster_stacks(geo, &cl, c, c0);
}
}
fn cluster_columns(&mut self, geo: &Geo, cl: &Cluster, c: usize, c0: f64) {
for (i, &s) in cl.columns.iter().enumerate() {
let Some(v) = self.cell(c, s) else { continue };
let a = c0 + cl.slot * i as f64 + (cl.slot - cl.bar) / 2.0;
let paint = self.mark(s, true, Paint::None, 0.0);
let (v0, v1) = (geo.zero(geo.axis(s)), geo.vpos(geo.axis(s), v));
let rect = bar_rect(geo.horizontal, a, cl.bar, v0, v1);
let n = self.bar_node(Bar { s, rect, value: v, down: v1 < v0, per_unit: geo.per_unit(geo.axis(s)) }, paint, true);
self.push_series(s, n);
}
}
fn cluster_stacks(&mut self, geo: &Geo, cl: &Cluster, c: usize, c0: f64) {
// Each axis stacks its own series.
let (mut pos, mut neg) = ([0.0f64; 2], [0.0f64; 2]);
for &s in &cl.stacks {
let Some(v) = self.cell(c, s) else { continue };
let ax = geo.axis(s);
let (a, w) = cl.place(geo, c, c0, ax);
let Some(base) = (if v >= 0.0 { pos.get_mut(ax) } else { neg.get_mut(ax) }) else { continue };
let (v0, v1) = (geo.vpos(ax, *base), geo.vpos(ax, *base + v));
*base += v;
let (stroke, width) = self.mark_stroke(s);
let paint = self.mark(s, true, stroke, width);
let rect = bar_rect(geo.horizontal, a, w, v0, v1);
// A segment of 0 has no area to shade.
let n = self.bar_node(Bar { s, rect, value: v, down: v1 < v0, per_unit: geo.per_unit(ax) }, paint, v != 0.0);
self.push_series(s, n);
}
}
/// Cumulative area bands, each from the previous area total on its axis up to its own.
fn areas(&mut self, geo: &Geo) {
let ncat = self.ncat;
let mut belows: [Vec<f64>; 2] = [vec![0.0; ncat], vec![0.0; ncat]];
for s in self.series_of(GraphKind::Area) {
let a = geo.axis(s);
let Some(below) = belows.get_mut(a) else { continue };
let above: Vec<f64> = below.iter().enumerate().map(|(c, b)| b + self.val(c, s)).collect();
// Mixed with series at the category centres, areas take their points there too.
let at = |c: usize, v: &[f64]| Point::new(geo.cat_mid(c), geo.vpos(a, v.get(c).copied().unwrap_or(0.0)));
let mut pts: Vec<Point> = (0..ncat).map(|c| at(c, &above)).collect();
pts.extend((0..ncat).rev().map(|c| at(c, below)));
let (stroke, width) = self.mark_stroke(s);
let (fill, stroke, w) = self.mark(s, true, stroke, width);
let n = self.b.path(polyline(&pts, true), fill, stroke, w);
self.push_series(s, n);
*below = above;
}
}
fn lines(&mut self, geo: &Geo) {
let g = self.g;
for s in self.series_of(GraphKind::Line) {
let pts: Vec<Option<Point>> = (0..self.ncat)
.map(|c| self.cell(c, s).map(|v| Point::new(geo.mid(c, g.edge_to_edge && geo.label_edges), geo.vpos(geo.axis(s), v))))
.collect();
if g.connect_points {
for run in runs(&pts) {
let n = self.b.data_line(g, s, polyline(&run, false), self.filled);
self.push_shadowed(s, n);
}
}
self.point_markers(s, &pts);
}
}
// ---- Legend and layering ----
/// Legend: a swatch + label per series, right of the plot; the swatch joins its series group. Returns the labels.
fn legend(&mut self) -> Vec<Arc<Node>> {
let g = self.g;
let legend_on = g.legend && !g.series.is_empty() && !(g.kind == GraphKind::Pie && g.pie_legend_in_wedges);
if !legend_on {
return vec![];
}
if g.legend_across_top { self.legend_across_top() } else { self.legend_beside() }
}
fn legend_series(&self) -> usize {
if self.g.kind == GraphKind::Scatter { self.nser.div_ceil(2) } else { self.nser }
}
fn legend_text(&self, s: usize) -> String {
if self.g.kind == GraphKind::Scatter { self.series_label(s * 2) } else { self.series_label(s) }
}
/// The swatch of series `s` at `(x, y)`: series drawn with markers show their marker design in the legend, and
/// series drawn with a column design that design. A default swatch has the stroke of its series' marks.
fn legend_swatch(&mut self, s: usize, (x, y): (f64, f64)) {
let marked = matches!(self.g.kind, GraphKind::Scatter | GraphKind::Radar) || self.kind(s) == GraphKind::Line;
let (stroke, width) = self.mark_stroke(s);
let paint = self.mark(s, true, stroke, width);
let column = nth(self.column_looks, s).filter(|_| self.columnar(s));
let swatch = self.b.swatch(column, nth(&self.designs, s).filter(|_| marked), Rect::new(x, y, x + 8.0, y + 8.0), paint);
self.push_series(s, swatch);
}
fn legend_label(&mut self, (x, y): (f64, f64), label: &str) -> Arc<Node> {
let ls = self.ls;
let (dx, dy) = label_shift(&self.g.label_styles, label, self.b.d.setup.system_layout);
let (x, y) = (x + dx, y + dy);
self.b.label(Role::Legend, Point::new(x + 12.0, y + 7.5 + (ls - LABEL_SIZE) * 0.35), label, Justify::Left, false)
}
/// Add Legend Across Top: swatch and label after swatch and label, in rows as wide as the plot, the last row
/// just above it.
fn legend_across_top(&mut self) -> Vec<Arc<Node>> {
let (g, r, ls, system_layout) = (self.g, self.r, self.ls, self.b.d.setup.system_layout);
let entries: Vec<(usize, String)> = (0..self.legend_series()).map(|s| (s, self.legend_text(s))).filter(|(_, l)| !blank_label(l)).collect();
let mut rows: Vec<Vec<(usize, String, f64, f64)>> = vec![vec![]];
let mut used = 0.0;
for (s, label) in entries {
let w = 12.0 + label_width(&g.label_styles, &label, system_layout) + 12.0;
let h = ls * 1.8 * label.split('|').count() as f64 + label_extra_height(&g.label_styles, &label, system_layout);
// The gap after an entry may run past the plot's edge.
if used + w - 12.0 > r.width() && rows.last().is_some_and(|row| !row.is_empty()) {
rows.push(vec![]);
used = 0.0;
}
used += w;
if let Some(row) = rows.last_mut() {
row.push((s, label, w, h));
}
}
let height = |row: &[(usize, String, f64, f64)]| row.iter().map(|(.., h)| *h).fold(ls * 1.8, f64::max);
// Above the plot and anything drawn over it (radar and stacked-pie labels).
let top = self.b.out.iter().chain(self.on_top.iter()).filter_map(|n| n.geometric_bounds()).map(|bb| bb.y0).fold(r.y0, f64::min);
let top = self.bars_reach.map_or(top, |b| top.min(b.y0));
let mut y = top - 8.0 - rows.iter().map(|row| height(row)).sum::<f64>();
let mut labels = vec![];
for row in &rows {
let mut x = r.x0;
for (s, label, w, _) in row {
self.legend_swatch(*s, (x, y));
labels.push(self.legend_label((x, y), label));
x += w;
}
y += height(row);
}
labels
}
fn legend_beside(&mut self) -> Vec<Arc<Node>> {
let (r, ls) = (self.r, self.ls);
let x = self.bars_reach.map_or(self.right_edge, |b| self.right_edge.max(b.x1)) + 14.0;
// Each row as tall as its label's lines (a `|` in a label starts a new line).
let mut y = r.y0;
let mut labels = vec![];
for s in 0..self.legend_series() {
let label = self.legend_text(s);
let row_y = y;
if blank_label(&label) {
y += ls * 1.8;
continue;
}
y += ls * 1.8 * label.split('|').count() as f64 + label_extra_height(&self.g.label_styles, &label, self.b.d.setup.system_layout);
self.legend_swatch(s, (x, row_y));
labels.push(self.legend_label((x, row_y), &label));
}
labels
}
/// Areas at the back, lines and points in front of columns; one graph type keeps the series order.
fn depth(&self, s: usize) -> u8 {
match self.kind(s) {
GraphKind::Area => 0,
GraphKind::Line => 2,
_ => 1,
}
}
/// Add Drop Shadow: a translucent black copy of each column, bar, line and wedge, a little down and right, just
/// behind the series of its layer (areas, columns, lines), so a layer in front doesn't hide the shadows of the one
/// behind. Left out past SHADOW_BUDGET marks.
fn finish(mut self, mut labels: Vec<Arc<Node>>) -> Option<Vec<Arc<Node>>> {
let g = self.g;
if !g.drop_shadow || self.shadowed.len() > SHADOW_BUDGET {
self.shadowed.clear();
}
let mut series: Vec<(usize, Vec<Arc<Node>>)> = std::mem::take(&mut self.series).into_iter().enumerate().collect();
// First Column in Front: the first series drawn last in its layer, over the others.
if g.first_column_in_front {
series.reverse();
}
series.sort_by_key(|(s, _)| self.depth(*s));
let mut layer = None;
for (s, items) in series {
if items.is_empty() {
continue;
}
let depth = self.depth(s);
if layer != Some(depth) {
layer = Some(depth);
let casting: Vec<Arc<Node>> = self.shadowed.iter().filter(|(t, _)| self.depth(*t) == depth).map(|(_, n)| n.clone()).collect();
let copies: Vec<Arc<Node>> = casting.iter().map(|n| shadow_of(self.b.d, n)).collect();
if !copies.is_empty() {
let mut grp = Node::group(self.b.d.alloc_id(), copies);
grp.name = Some("Drop Shadow".into());
grp.opacity = SHADOW_OPACITY;
self.b.out.push(Arc::new(grp));
}
}
let name = g.series.get(s).cloned().filter(|n| !n.is_empty()).unwrap_or_else(|| format!("Series {}", s + 1));
let grp = with_series_group_opacity(g, s, self.b.series(&name, s, with_series_opacity(g, s, with_series_gradients(g, s, items))));
self.b.out.push(grp);
}
self.b.out.append(&mut self.on_top);
labels.append(&mut self.wedge_labels);
if !labels.is_empty() {
let grp = self.b.group("Legend", labels);
self.b.out.push(grp);
}
(!self.b.columns.short).then_some(self.b.out)
}
}
pub(super) fn children_bounds(children: &[Arc<Node>]) -> Option<Rect> {
children.iter().filter_map(|c| c.geometric_bounds()).reduce(|a, b| a.union(b))
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.