rust-office-charts 0.1.7

Render Office Open XML charts to SVG from native Rust or WebAssembly
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use super::{line, text, text_width, Coords};
use std::collections::BTreeMap;

pub(super) type Hierarchy = BTreeMap<usize, BTreeMap<u32, String>>;

fn band_extent(labels: &BTreeMap<u32, String>, size: f64, horizontal: bool) -> f64 {
    if horizontal {
        size * 2.0
    } else {
        labels
            .values()
            .map(|s| text_width(s, size))
            .fold(0., f64::max)
            + size * 0.9
    }
}

pub(super) fn extent(hierarchy: &Hierarchy, size: f64, horizontal: bool) -> f64 {
    hierarchy
        .values()
        .map(|labels| band_extent(labels, size, horizontal))
        .sum()
}

pub(super) fn leaf_extent(
    labels: &BTreeMap<u32, String>,
    size: f64,
    rotation: f64,
    horizontal: bool,
) -> f64 {
    let width = labels
        .values()
        .map(|s| text_width(s, size))
        .fold(0., f64::max);
    if !horizontal {
        width + size * 0.9
    } else if rotation == 0. {
        size * 2.29
    } else {
        width * rotation.to_radians().abs().sin() + size * 1.4
    }
}

pub(super) fn draw(
    svg: &mut String,
    hierarchy: &Hierarchy,
    coords: &Coords,
    axis_position: f64,
    leaf_extent: f64,
    size: f64,
    face: &str,
    stroke: &str,
    side: &str,
) {
    let horizontal = !coords.horizontal;
    let direction = if side == "l" || side == "t" { -1. } else { 1. };
    let count = coords.count.min(u32::MAX as f64) as u32;
    let edge = |index: u32| {
        let (x, y) = coords.point(f64::from(index) - 0.5, 0.);
        if horizontal {
            x.clamp(coords.rect.left, coords.rect.right)
        } else {
            y.clamp(coords.rect.top, coords.rect.bottom)
        }
    };
    let mut offset = leaf_extent;
    for (&level, labels) in hierarchy {
        let band = band_extent(labels, size, horizontal);
        let inner = axis_position + direction * offset;
        let outer = inner + direction * band;
        for (&start, label) in labels.range(..count) {
            let end = hierarchy
                .range(level..)
                .filter_map(|(_, entries)| {
                    entries
                        .range((std::ops::Bound::Excluded(start), std::ops::Bound::Unbounded))
                        .next()
                        .map(|(&i, _)| i)
                })
                .min()
                .unwrap_or(count)
                .min(count);
            if end <= start {
                continue;
            }
            let a = edge(start);
            let b = edge(end);
            let center = (a + b) * 0.5;
            if horizontal {
                line(svg, a, axis_position, a, outer, stroke);
                line(svg, b, axis_position, b, outer, stroke);
                text(
                    svg,
                    center,
                    (inner + outer) * 0.5 + size * 0.31,
                    "middle",
                    size,
                    face,
                    label,
                    false,
                );
            } else {
                line(svg, axis_position, a, outer, a, stroke);
                line(svg, axis_position, b, outer, b, stroke);
                text(
                    svg,
                    (inner + outer) * 0.5,
                    center + size * 0.31,
                    "middle",
                    size,
                    face,
                    label,
                    false,
                );
            }
        }
        offset += band;
    }
}