nu_plugin_plotters 0.2.5+0.111.0

A nushell plugin for for plotting charts
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
120
121
122
123
124
125
126
127
128

use plotters::chart::{ChartBuilder, ChartContext, LabelAreaPosition};
use plotters::coord::Shift;
use plotters::prelude::{Cartesian2d, DrawingArea, DrawingBackend, Rectangle};
use plotters::series::LineSeries;
use plotters::style::{BLACK, RGBAColor, ShapeStyle};

use crate::value::{
    self, Bar2dSeries, Coord1d, Coord2d, Line2dSeries, Range, RangeMetadata, Series2d,
};

mod png;
pub use png::*;

mod svg;
pub use svg::*;

mod terminal;
pub use terminal::*;

fn draw<DB: DrawingBackend>(chart: value::Chart2d, drawing_area: DrawingArea<DB, Shift>) {
    if chart.series.is_empty() {
        todo!("return some error that empty series do not work")
    }

    // TODO: make better error
    let mut x_range = chart.x_range().unwrap();
    let y_range = chart.y_range().unwrap();

    // bar charts typically want to display all the discrete points
    if chart
        .series
        .iter()
        .any(|series| matches!(series, Series2d::Bar(_)))
    {
        x_range.metadata = Some(RangeMetadata {
            discrete_key_points: true,
        });
    }

    if let Some(color) = chart.background {
        let color: RGBAColor = color.into();
        drawing_area.fill(&color).unwrap();
    }

    let mut chart_builder = ChartBuilder::on(&drawing_area);

    let [top, right, bottom, left] = chart.margin;
    chart_builder.margin_top(top);
    chart_builder.margin_right(right);
    chart_builder.margin_bottom(bottom);
    chart_builder.margin_left(left);

    let [top, right, bottom, left] = chart.label_area;
    chart_builder.set_label_area_size(LabelAreaPosition::Top, top);
    chart_builder.set_label_area_size(LabelAreaPosition::Right, right);
    chart_builder.set_label_area_size(LabelAreaPosition::Bottom, bottom);
    chart_builder.set_label_area_size(LabelAreaPosition::Left, left);

    if let Some(caption) = chart.caption {
        chart_builder.caption(caption, &BLACK);
    }

    let mut chart_context = chart_builder.build_cartesian_2d(x_range, y_range).unwrap();

    let mut mesh = chart_context.configure_mesh();
    if !chart.x_mesh {
        mesh.disable_x_mesh();
    };
    if !chart.y_mesh {
        mesh.disable_y_mesh();
    };
    mesh.draw().unwrap();

    for series in chart.series {
        match series {
            value::Series2d::Line(series) => draw_line(&mut chart_context, series),
            value::Series2d::Bar(series) => draw_vertical_bar(&mut chart_context, series),
        }
    }
}

fn draw_line<DB: DrawingBackend>(
    chart_context: &mut ChartContext<DB, Cartesian2d<Range, Range>>,
    series: Line2dSeries,
) {
    let Line2dSeries {
        series,
        color,
        filled,
        stroke_width,
        point_size,
    } = series;
    let shape_style = ShapeStyle {
        color: color.into(),
        filled,
        stroke_width,
    };
    let series = LineSeries::new(
        series.into_iter().map(|value::Coord2d { x, y }| (x, y)),
        shape_style,
    )
    .point_size(point_size);
    chart_context.draw_series(series).unwrap();
}

fn draw_vertical_bar<DB: DrawingBackend>(
    chart_context: &mut ChartContext<DB, Cartesian2d<Range, Range>>,
    series: Bar2dSeries,
) {
    let Bar2dSeries {
        series,
        color,
        filled,
        stroke_width,
    } = series;
    let shape_style = ShapeStyle {
        color: color.into(),
        filled,
        stroke_width,
    };
    let rect_iter = series.into_iter().map(|Coord2d { x, y }| {
        let half_width = Coord1d::Float(0.8) / Coord1d::Int(2);
        let value_point = (x - half_width, y);
        let base_point = (x + half_width, Coord1d::Int(0));
        Rectangle::new([value_point, base_point], shape_style)
    });
    chart_context.draw_series(rect_iter).unwrap();
}