liecharts 0.1.0-beta

A Rust charting library with PNG and SVG rendering support
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

use crate::component::{ChartComponent, SeriesComponent, SeriesContext};
use crate::layout::LayoutOutput;
use crate::model::{BarSeries, ResolvedOption};
use crate::pipeline::mapper::{CoordinateMapper, CartesianBarMapper};
use crate::pipeline::transform::{DataTransformer, IdentityTransformer};
use crate::pipeline::builder::{VisualBuilder, BarVisualBuilder};
use crate::visual::{Stroke, VisualElement};

pub struct BarSeriesComponent {
    series: BarSeries,
    series_index: usize,
    grid_index: usize,
}

impl BarSeriesComponent {
    pub fn new(series: &BarSeries, series_index: usize, grid_index: usize) -> Self {
        Self {
            series: series.clone(),
            series_index,
            grid_index,
        }
    }

    fn build_with_context(&self, ctx: &SeriesContext) -> Vec<VisualElement> {
        let coord = ctx.coord;

        // 1. Transform
        let resolved_series = crate::model::ResolvedSeries::Bar(self.series.clone());
        let transformer = IdentityTransformer;
        let transformed_list = transformer.transform(&[resolved_series]);
        let transformed = &transformed_list[0];

        // 2. Map
        let cat_width = coord.category_width();
        let bar_width = self.series.bar_width.unwrap_or(cat_width * 0.6);
        let bar_width_ratio = bar_width / cat_width;

        let mapper = CartesianBarMapper::new()
            .with_bar_width_ratio(bar_width_ratio);
        let mapped = mapper.map(transformed, coord, self.series.y_axis_index);

        // 3. Build
        let color = ctx.get_series_color(self.series.item_style.color);

        let border_stroke = self.series.item_style.border_color.map(|c| Stroke {
            color: c,
            width: self.series.item_style.border_width,
        });

        let series_style = crate::pipeline::SeriesStyle {
            color,
            stroke: border_stroke,
            fill: Some(color),
        };

        let label_config = if let Some(label) = &self.series.label {
            if label.show {
                use crate::pipeline::LabelPosition as PL;
                let pos = match label.position {
                    crate::model::LabelPosition::Top => PL::Top,
                    crate::model::LabelPosition::Inside => PL::Inside,
                    _ => PL::Top,
                };
                crate::pipeline::LabelConfig {
                    show: true,
                    position: pos,
                    color: label.color,
                    font_size: label.font_size,
                    font_family: label.font_family.clone(),
                    formatter: None,
                }
            } else {
                crate::pipeline::LabelConfig::default()
            }
        } else {
            crate::pipeline::LabelConfig::default()
        };

        let builder = BarVisualBuilder::new()
            .with_series_style(series_style)
            .with_label_config(label_config);

        builder.build(transformed, &mapped, coord)
    }
}

impl SeriesComponent for BarSeriesComponent {
    fn series_index(&self) -> usize {
        self.series_index
    }

    fn grid_index(&self) -> usize {
        self.grid_index
    }

    fn is_empty(&self) -> bool {
        self.series.data.is_empty()
    }
}

impl ChartComponent for BarSeriesComponent {
    fn build_visual_elements(&self, resolved: &ResolvedOption, layout: &LayoutOutput) -> Vec<VisualElement> {
        let ctx = match self.create_context(resolved, layout) {
            Some(ctx) => ctx,
            None => return Vec::new(),
        };
        self.build_with_context(&ctx)
    }
}