use std::path::Path;
use crate::error::{Med64Error, Result};
#[derive(Debug, Clone)]
pub struct SvgStyle {
pub background: String,
pub grid: String,
pub axis: String,
pub text: String,
pub muted: String,
pub font: String,
pub stroke_width: f64,
}
impl Default for SvgStyle {
fn default() -> Self {
Self {
background: "#fafafa".into(),
grid: "#e2e8f0".into(),
axis: "#64748b".into(),
text: "#0f172a".into(),
muted: "#64748b".into(),
font: "Helvetica Neue,Helvetica,Arial,sans-serif".into(),
stroke_width: 1.75,
}
}
}
#[derive(Debug, Clone)]
pub struct SvgChartOptions {
pub width: u32,
pub height: u32,
pub title: String,
pub xlabel: String,
pub ylabel: String,
pub style: SvgStyle,
pub show_grid: bool,
pub x_ticks: usize,
pub y_ticks: usize,
pub margin_left: f64,
pub margin_right: f64,
pub margin_top: f64,
pub margin_bottom: f64,
pub max_points: Option<usize>,
}
impl Default for SvgChartOptions {
fn default() -> Self {
Self {
width: 800,
height: 280,
title: String::new(),
xlabel: String::new(),
ylabel: String::new(),
style: SvgStyle::default(),
show_grid: true,
x_ticks: 5,
y_ticks: 5,
margin_left: 64.0,
margin_right: 16.0,
margin_top: 40.0,
margin_bottom: 48.0,
max_points: Some(4000),
}
}
}
#[derive(Debug, Clone)]
pub struct SvgSeries {
pub label: String,
pub points: Vec<(f64, f64)>,
pub color: String,
pub fill: bool,
}
pub fn escape_xml(s: &str) -> String {
let mut out = String::with_capacity(s.len());
for c in s.chars() {
match c {
'&' => out.push_str("&"),
'<' => out.push_str("<"),
'>' => out.push_str(">"),
'"' => out.push_str("""),
'\'' => out.push_str("'"),
_ => out.push(c),
}
}
out
}
pub fn downsample_lttb(points: &[(f64, f64)], n: usize) -> Vec<(f64, f64)> {
if n == 0 || points.is_empty() {
return Vec::new();
}
if points.len() <= n {
return points.to_vec();
}
if n == 1 {
return vec![points[0]];
}
if n == 2 {
return vec![points[0], *points.last().unwrap()];
}
let mut sampled = Vec::with_capacity(n);
sampled.push(points[0]);
let data_len = points.len();
let bucket_size = (data_len - 2) as f64 / (n - 2) as f64;
let mut a = 0usize;
for i in 0..(n - 2) {
let mut range_offs = ((i as f64 + 1.0) * bucket_size).floor() as usize + 1;
let mut range_to = (((i as f64 + 2.0) * bucket_size).floor() as usize + 1).min(data_len);
range_offs = range_offs.min(data_len - 1);
range_to = range_to.max(range_offs + 1).min(data_len);
let mut avg_range_start = ((i as f64 + 2.0) * bucket_size).floor() as usize + 1;
let mut avg_range_end =
(((i as f64 + 3.0) * bucket_size).floor() as usize + 1).min(data_len);
if i == n - 3 {
avg_range_start = data_len - 1;
avg_range_end = data_len;
}
avg_range_start = avg_range_start.min(data_len - 1);
avg_range_end = avg_range_end.max(avg_range_start + 1).min(data_len);
let avg_range = &points[avg_range_start..avg_range_end];
let avg_len = avg_range.len() as f64;
let (avg_x, avg_y) = if avg_len > 0.0 {
let mut sx = 0.0;
let mut sy = 0.0;
for p in avg_range {
sx += p.0;
sy += p.1;
}
(sx / avg_len, sy / avg_len)
} else {
points[data_len - 1]
};
let point_a = points[a];
let mut max_area = -1.0_f64;
let mut next_a = range_offs;
for (idx, p) in points[range_offs..range_to].iter().enumerate() {
let area = ((point_a.0 - avg_x) * (p.1 - point_a.1)
- (point_a.0 - p.0) * (avg_y - point_a.1))
.abs()
* 0.5;
if area > max_area {
max_area = area;
next_a = range_offs + idx;
}
}
sampled.push(points[next_a]);
a = next_a;
}
sampled.push(*points.last().unwrap());
sampled
}
fn nice_num(range: f64, round: bool) -> f64 {
if !range.is_finite() || range <= 0.0 {
return 1.0;
}
let exp = range.log10().floor();
let frac = range / 10f64.powf(exp);
let nice = if round {
if frac < 1.5 {
1.0
} else if frac < 3.0 {
2.0
} else if frac < 7.0 {
5.0
} else {
10.0
}
} else if frac <= 1.0 {
1.0
} else if frac <= 2.0 {
2.0
} else if frac <= 5.0 {
5.0
} else {
10.0
};
nice * 10f64.powf(exp)
}
fn nice_ticks(min: f64, max: f64, max_ticks: usize) -> Vec<f64> {
let max_ticks = max_ticks.max(2);
let span = (max - min).abs();
if !span.is_finite() || span < 1e-15 {
return vec![min, max.max(min + 1.0)];
}
let range = nice_num(span, false);
let step = nice_num(range / (max_ticks - 1) as f64, true).max(1e-15);
let nice_min = (min / step).floor() * step;
let nice_max = (max / step).ceil() * step;
let mut ticks = Vec::new();
let mut v = nice_min;
for _ in 0..max_ticks.saturating_mul(4).max(8) {
if v > nice_max + step * 0.5 {
break;
}
if v >= min - step * 0.01 && v <= max + step * 0.01 {
ticks.push(v);
} else if v >= nice_min - 1e-12 && v <= nice_max + 1e-12 {
ticks.push(v);
}
v += step;
if ticks.len() > max_ticks + 4 {
break;
}
}
if ticks.is_empty() {
ticks.push(min);
ticks.push(max);
}
ticks
}
fn format_tick(v: f64) -> String {
let a = v.abs();
if a >= 1000.0 || (a > 0.0 && a < 0.01) {
format!("{v:.2e}")
} else if (v - v.round()).abs() < 1e-9 * a.max(1.0) {
format!("{:.0}", v.round())
} else if a >= 10.0 {
format!("{v:.1}")
} else {
format!("{v:.2}")
}
}
fn plot_frame(opts: &SvgChartOptions) -> (f64, f64, f64, f64) {
let left = opts.margin_left;
let right = opts.margin_right;
let top = opts.margin_top;
let bottom = opts.margin_bottom;
let pw = (opts.width as f64 - left - right).max(1.0);
let ph = (opts.height as f64 - top - bottom).max(1.0);
(left, top, pw, ph)
}
fn data_bounds_xy(points: impl Iterator<Item = (f64, f64)>) -> (f64, f64, f64, f64) {
let mut min_x = f64::INFINITY;
let mut max_x = f64::NEG_INFINITY;
let mut min_y = f64::INFINITY;
let mut max_y = f64::NEG_INFINITY;
let mut any = false;
for (x, y) in points {
if x.is_finite() && y.is_finite() {
any = true;
min_x = min_x.min(x);
max_x = max_x.max(x);
min_y = min_y.min(y);
max_y = max_y.max(y);
}
}
if !any {
return (0.0, 1.0, 0.0, 1.0);
}
if (max_x - min_x).abs() < 1e-12 {
max_x = min_x + 1.0;
}
if (max_y - min_y).abs() < 1e-12 {
if min_y == 0.0 {
max_y = 1.0;
} else {
min_y -= min_y.abs() * 0.05;
max_y += max_y.abs() * 0.05;
}
}
(min_x, max_x, min_y, max_y)
}
fn path_d(points: &[(f64, f64)], map: impl Fn(f64, f64) -> (f64, f64)) -> String {
let mut d = String::new();
for (i, &(x, y)) in points.iter().enumerate() {
let (px, py) = map(x, y);
if i == 0 {
d.push_str(&format!("M{px:.2} {py:.2}"));
} else {
d.push_str(&format!("L{px:.2} {py:.2}"));
}
}
d
}
fn svg_open(opts: &SvgChartOptions) -> String {
let w = opts.width;
let h = opts.height;
let bg = escape_xml(&opts.style.background);
format!(
r##"<svg xmlns="http://www.w3.org/2000/svg" width="{w}" height="{h}" viewBox="0 0 {w} {h}">
<rect width="100%" height="100%" fill="{bg}"/>
"##
)
}
fn draw_axes_chrome(
body: &mut String,
opts: &SvgChartOptions,
left: f64,
top: f64,
pw: f64,
ph: f64,
min_x: f64,
max_x: f64,
min_y: f64,
max_y: f64,
clip_id: &str,
) {
let style = &opts.style;
let font = escape_xml(&style.font);
let text = escape_xml(&style.text);
let muted = escape_xml(&style.muted);
let axis = escape_xml(&style.axis);
let grid = escape_xml(&style.grid);
let xr = left + pw;
let yb = top + ph;
let cx = opts.width as f64 / 2.0;
body.push_str(&format!(
r##" <defs>
<clipPath id="{clip_id}"><rect x="{left:.2}" y="{top:.2}" width="{pw:.2}" height="{ph:.2}"/></clipPath>
</defs>
"##
));
if !opts.title.is_empty() {
body.push_str(&format!(
r##" <text x="{cx:.1}" y="22" text-anchor="middle" font-family="{font}" font-size="14" fill="{text}">{title}</text>
"##,
title = escape_xml(&opts.title)
));
}
let x_ticks = nice_ticks(min_x, max_x, opts.x_ticks);
let y_ticks = nice_ticks(min_y, max_y, opts.y_ticks);
let span_x = (max_x - min_x).max(1e-15);
let span_y = (max_y - min_y).max(1e-15);
if opts.show_grid {
for &tx in &x_ticks {
let px = left + (tx - min_x) / span_x * pw;
body.push_str(&format!(
r##" <line x1="{px:.2}" y1="{top:.2}" x2="{px:.2}" y2="{yb:.2}" stroke="{grid}" stroke-width="1"/>
"##
));
}
for &ty in &y_ticks {
let py = top + ph - (ty - min_y) / span_y * ph;
body.push_str(&format!(
r##" <line x1="{left:.2}" y1="{py:.2}" x2="{xr:.2}" y2="{py:.2}" stroke="{grid}" stroke-width="1"/>
"##
));
}
}
if min_y < 0.0 && max_y > 0.0 {
let zy = top + ph - (0.0 - min_y) / span_y * ph;
body.push_str(&format!(
r##" <line x1="{left:.2}" y1="{zy:.2}" x2="{xr:.2}" y2="{zy:.2}" stroke="{axis}" stroke-width="1" stroke-dasharray="4 3"/>
"##
));
}
body.push_str(&format!(
r##" <line x1="{left:.2}" y1="{top:.2}" x2="{left:.2}" y2="{yb:.2}" stroke="{axis}" stroke-width="1.2"/>
<line x1="{left:.2}" y1="{yb:.2}" x2="{xr:.2}" y2="{yb:.2}" stroke="{axis}" stroke-width="1.2"/>
"##
));
for &tx in &x_ticks {
let px = left + (tx - min_x) / span_x * pw;
body.push_str(&format!(
r##" <line x1="{px:.2}" y1="{yb:.2}" x2="{px:.2}" y2="{tick_y:.2}" stroke="{axis}" stroke-width="1"/>
<text x="{px:.2}" y="{label_y:.2}" text-anchor="middle" font-family="{font}" font-size="9" fill="{muted}">{label}</text>
"##,
tick_y = yb + 5.0,
label_y = yb + 16.0,
label = escape_xml(&format_tick(tx))
));
}
for &ty in &y_ticks {
let py = top + ph - (ty - min_y) / span_y * ph;
body.push_str(&format!(
r##" <line x1="{left:.2}" y1="{py:.2}" x2="{tick_x:.2}" y2="{py:.2}" stroke="{axis}" stroke-width="1"/>
<text x="{label_x:.2}" y="{py:.2}" dy="0.35em" text-anchor="end" font-family="{font}" font-size="9" fill="{muted}">{label}</text>
"##,
tick_x = left - 4.0,
label_x = left - 8.0,
label = escape_xml(&format_tick(ty))
));
}
if !opts.xlabel.is_empty() {
body.push_str(&format!(
r##" <text x="{cx:.1}" y="{hy:.1}" text-anchor="middle" font-family="{font}" font-size="11" fill="{text}">{xlabel}</text>
"##,
hy = opts.height as f64 - 10.0,
xlabel = escape_xml(&opts.xlabel)
));
}
if !opts.ylabel.is_empty() {
let ymy = top + ph / 2.0;
body.push_str(&format!(
r##" <text x="14" y="{ymy:.1}" text-anchor="middle" transform="rotate(-90 14 {ymy:.1})" font-family="{font}" font-size="11" fill="{text}">{ylabel}</text>
"##,
ylabel = escape_xml(&opts.ylabel)
));
}
}
fn prepare_series(series: &[SvgSeries], max_points: Option<usize>) -> Vec<SvgSeries> {
series
.iter()
.map(|s| {
let pts = match max_points {
Some(n) if s.points.len() > n => downsample_lttb(&s.points, n),
_ => s.points.clone(),
};
SvgSeries { label: s.label.clone(), points: pts, color: s.color.clone(), fill: s.fill }
})
.collect()
}
pub fn render_line_svg(series: &[SvgSeries], opts: &SvgChartOptions) -> String {
let prepared = prepare_series(series, opts.max_points);
let (left, top, pw, ph) = plot_frame(opts);
let (min_x, max_x, min_y, max_y) =
data_bounds_xy(prepared.iter().flat_map(|s| s.points.iter().copied()));
let mut body = svg_open(opts);
let clip_id = "plot-clip";
draw_axes_chrome(&mut body, opts, left, top, pw, ph, min_x, max_x, min_y, max_y, clip_id);
let span_x = (max_x - min_x).max(1e-15);
let span_y = (max_y - min_y).max(1e-15);
let map = |x: f64, y: f64| {
let px = left + (x - min_x) / span_x * pw;
let py = top + ph - (y - min_y) / span_y * ph;
(px, py)
};
body.push_str(&format!(
r##" <g clip-path="url(#{clip_id})">
"##
));
let sw = opts.style.stroke_width;
for s in &prepared {
if s.points.is_empty() {
continue;
}
let d = path_d(&s.points, map);
let color = escape_xml(&s.color);
if s.fill {
let baseline_y = if min_y <= 0.0 && max_y >= 0.0 { 0.0 } else { min_y };
let (x0, _) = map(s.points[0].0, s.points[0].1);
let (x1, _) = map(s.points.last().unwrap().0, s.points.last().unwrap().1);
let (_, by) = map(0.0, baseline_y);
let fill_d = format!("{d}L{x1:.2} {by:.2}L{x0:.2} {by:.2}Z");
body.push_str(&format!(
r##" <path d="{fill_d}" fill="{color}" fill-opacity="0.18" stroke="none"/>
"##
));
}
body.push_str(&format!(
r##" <path d="{d}" fill="none" stroke="{color}" stroke-width="{sw}" stroke-linejoin="round" stroke-linecap="round"/>
"##
));
}
body.push_str(" </g>\n");
let labeled: Vec<_> = prepared.iter().filter(|s| !s.label.is_empty()).collect();
if labeled.len() > 1 || (labeled.len() == 1 && series.len() > 1) {
let font = escape_xml(&opts.style.font);
let text = escape_xml(&opts.style.text);
let mut ly = top + 4.0;
let lx = left + pw - 8.0;
for s in labeled {
let color = escape_xml(&s.color);
body.push_str(&format!(
r##" <line x1="{x0:.1}" y1="{ly:.1}" x2="{x1:.1}" y2="{ly:.1}" stroke="{color}" stroke-width="2"/>
<text x="{tx:.1}" y="{ty:.1}" text-anchor="end" font-family="{font}" font-size="10" fill="{text}">{label}</text>
"##,
x0 = lx - 90.0,
x1 = lx - 70.0,
tx = lx - 66.0,
ty = ly + 3.0,
label = escape_xml(&s.label)
));
ly += 14.0;
}
}
body.push_str("</svg>\n");
body
}
pub fn render_bar_svg(bars: &[(String, f64)], opts: &SvgChartOptions) -> String {
let (left, top, pw, ph) = plot_frame(opts);
let values: Vec<f64> = bars.iter().map(|(_, v)| *v).collect();
let min_y = values.iter().copied().fold(0.0_f64, f64::min).min(0.0);
let max_y = values.iter().copied().fold(1e-9_f64, f64::max).max(1e-9);
let n = bars.len().max(1) as f64;
let bar_w = pw / n;
let mut body = svg_open(opts);
let clip_id = "bar-clip";
draw_axes_chrome(&mut body, opts, left, top, pw, ph, 0.0, n, min_y, max_y, clip_id);
let span_y = (max_y - min_y).max(1e-15);
let font = escape_xml(&opts.style.font);
let muted = escape_xml(&opts.style.muted);
let yb = top + ph;
body.push_str(&format!(
r##" <g clip-path="url(#{clip_id})">
"##
));
for (i, (label, value)) in bars.iter().enumerate() {
let bh = ((*value - min_y) / span_y) * ph;
let x = left + i as f64 * bar_w + bar_w * 0.1;
let y = yb - bh;
let bw = (bar_w * 0.8).max(1.0);
body.push_str(&format!(
r##" <rect x="{x:.2}" y="{y:.2}" width="{bw:.2}" height="{bh:.2}" fill="#0891b2"/>
"##
));
if bars.len() <= 32 {
let tx = x + bw / 2.0;
body.push_str(&format!(
r##" <text x="{tx:.2}" y="{label_y:.2}" text-anchor="middle" font-family="{font}" font-size="8" fill="{muted}">{label}</text>
"##,
label_y = yb + 28.0,
label = escape_xml(label)
));
}
}
body.push_str(" </g>\n</svg>\n");
body
}
pub fn render_raster_svg(
rows: &[(usize, Vec<f64>)],
opts: &SvgChartOptions,
t_min: f64,
t_max: f64,
) -> String {
let (left, top, pw, ph) = plot_frame(opts);
let mut t0 = t_min;
let mut t1 = t_max;
if !(t1 > t0) {
t0 = 0.0;
t1 = 1.0;
}
let n = rows.len().max(1) as f64;
let mut body = svg_open(opts);
let clip_id = "raster-clip";
draw_axes_chrome(&mut body, opts, left, top, pw, ph, t0, t1, 0.0, n, clip_id);
let span_t = (t1 - t0).max(1e-15);
let stroke = escape_xml(&opts.style.text);
body.push_str(&format!(
r##" <g clip-path="url(#{clip_id})">
"##
));
for (row_i, (_ch, times)) in rows.iter().enumerate() {
let y = top + (row_i as f64 + 0.5) / n * ph;
for &t in times {
if t < t0 || t > t1 {
continue;
}
let x = left + (t - t0) / span_t * pw;
body.push_str(&format!(
r##" <line x1="{x:.2}" y1="{y0:.2}" x2="{x:.2}" y2="{y1:.2}" stroke="{stroke}" stroke-width="1"/>
"##,
y0 = y - 3.0,
y1 = y + 3.0
));
}
}
body.push_str(" </g>\n</svg>\n");
body
}
pub fn write_svg_file(path: impl AsRef<Path>, content: &str) -> Result<()> {
let path = path.as_ref();
std::fs::write(path, content)
.map_err(|source| Med64Error::WriteIo { path: path.to_path_buf(), source })
}
pub fn write_line_svg(
series: &[SvgSeries],
opts: &SvgChartOptions,
path: impl AsRef<Path>,
) -> Result<()> {
write_svg_file(path, &render_line_svg(series, opts))
}
pub fn write_bar_svg(
bars: &[(String, f64)],
opts: &SvgChartOptions,
path: impl AsRef<Path>,
) -> Result<()> {
write_svg_file(path, &render_bar_svg(bars, opts))
}
pub fn write_raster_svg(
rows: &[(usize, Vec<f64>)],
opts: &SvgChartOptions,
t_min: f64,
t_max: f64,
path: impl AsRef<Path>,
) -> Result<()> {
write_svg_file(path, &render_raster_svg(rows, opts, t_min, t_max))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn escape_xml_specials() {
assert_eq!(escape_xml(r#"a&b<c>"d'e"#), "a&b<c>"d'e");
}
#[test]
fn downsample_shrinks() {
let pts: Vec<(f64, f64)> = (0..10_000).map(|i| (i as f64, (i as f64).sin())).collect();
let out = downsample_lttb(&pts, 400);
assert!(out.len() <= 400);
assert!(out.len() >= 2);
assert_eq!(out.first(), pts.first());
assert_eq!(out.last(), pts.last());
}
#[test]
fn line_svg_contains_path_clip_tick() {
let series = [SvgSeries {
label: "demo".into(),
points: vec![(0.0, 0.0), (1.0, 2.0), (2.0, 1.0)],
color: "#2563eb".into(),
fill: false,
}];
let opts = SvgChartOptions {
title: "T & Title".into(),
xlabel: "X".into(),
ylabel: "Y".into(),
..Default::default()
};
let svg = render_line_svg(&series, &opts);
assert!(svg.contains("<path "));
assert!(svg.contains("clipPath"));
assert!(svg.contains("<line ")); assert!(svg.contains("T & Title"));
}
#[test]
fn empty_series_still_valid_svg() {
let opts = SvgChartOptions { title: "Empty".into(), ..Default::default() };
let svg = render_line_svg(&[], &opts);
assert!(svg.contains("<svg"));
assert!(svg.contains("</svg>"));
assert!(svg.contains("clipPath"));
}
}