fluent-plots 0.1.0

A declarative data visualization library with a fluent API, built on Polars and Charming.
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
129
130
131
132
133

use polars::prelude::*;
use plotters::prelude::*;
use std::error::Error;

#[cfg(feature = "interactive")]
use charming::{
    component::{Axis, Title},
    element::AxisType,
    series::{Bar, Line, Scatter, Series},
    Chart as CharmingChart,
};

#[derive(Clone)]
pub enum ChartType {
    Bar,
    Line,
    Scatter,
}

#[derive(Clone)]
pub struct Chart {
    chart_type: ChartType,
    dataframe: DataFrame,
    x_column: String,
    y_column: String,
}

pub fn barchart(dataframe: DataFrame) -> Chart {
    Chart {
        chart_type: ChartType::Bar,
        dataframe,
        x_column: String::new(),
        y_column: String::new(),
    }
}

pub fn linechart(dataframe: DataFrame) -> Chart {
    Chart {
        chart_type: ChartType::Line,
        dataframe,
        x_column: String::new(),
        y_column: String::new(),
    }
}

pub fn scatterplot(dataframe: DataFrame) -> Chart {
    Chart {
        chart_type: ChartType::Scatter,
        dataframe,
        x_column: String::new(),
        y_column: String::new(),
    }
}

impl Chart {
    pub fn x(mut self, column_name: &str) -> Self {
        self.x_column = column_name.to_string();
        self
    }

    pub fn y(mut self, column_name: &str) -> Self {
        self.y_column = column_name.to_string();
        self
    }

    pub fn draw(&self, path: &str) -> std::result::Result<(), Box<dyn Error>> {
        let root = BitMapBackend::new(path, (640, 480)).into_drawing_area();
        root.fill(&WHITE)?;

        println!("Drawing static chart with x='{}' and y='{}'", self.x_column, self.y_column);

        root.present()?;
        Ok(())
    }
}

#[cfg(feature = "interactive")]
impl Chart {
    pub fn to_interactive_html(&self) -> std::result::Result<String, Box<dyn Error>> {
        let x_data: Vec<String> = self
            .dataframe
            .column(&self.x_column)?
            .str()?
            .into_iter()
            .map(|opt_val| opt_val.unwrap_or("").to_string())
            .collect();

        let y_data: Vec<f64> = self
            .dataframe
            .column(&self.y_column)?
            .cast(&DataType::Float64)?
            .f64()?
            .into_iter()
            .map(|opt_val| opt_val.unwrap_or(0.0))
            .collect();

        let series: Series = match self.chart_type {
            ChartType::Bar => Bar::new().data(y_data).into(),
            ChartType::Line => Line::new().data(y_data).into(),
            ChartType::Scatter => Scatter::new().data(y_data).into(),
        };

        let chart = CharmingChart::new()
            .title(Title::new().text("fluent-plots chart"))
            .x_axis(Axis::new().type_(AxisType::Category).data(x_data))
            .y_axis(Axis::new().type_(AxisType::Value))
            .series(series);

        let html = format!(
            r#"
            <!DOCTYPE html>
            <html>
            <head>
                <meta charset="utf-8" />
                <title>Fluent-Plots Chart</title>
                <script src="https://cdn.jsdelivr.net/npm/echarts@5.5.0/dist/echarts.min.js"></script>
            </head>
            <body>
                <div id="main" style="width: 800px;height:600px;"></div>
                <script type="text/javascript">
                    var myChart = echarts.init(document.getElementById('main'));
                    var option = {json_config};
                    myChart.setOption(option);
                </script>
            </body>
            </html>
            "#,
            json_config = chart.to_string()
        );

        Ok(html)
    }
}