Rust语言从入门到精通系列 - 支持WASM的高性能绘图库Plotters

Plotters 是一个基于 Rust 语言的绘图库，由 Eonil 和其他贡献者开发。它的目标是提供一个简单易用的 API，可以轻松地创建各种类型的图表，并支持多种输出格式。Plotters 使用 Rust 语言的强类型系统和高性能，可以生成高质量的图表。

Plotters 提供了多种类型的图表，包括线图、柱状图、散点图等等。它还支持多种输出格式，包括 PNG、SVG、PDF 等等。使用 Plotters 可以轻松地创建高质量的图表，同时还可以自定义图表的样式和布局。

用法实战#

安装 Plotters#

在使用 Plotters 之前，需要安装 Plotters。可以通过以下命令安装 Plotters：

1
cargo install plotters

绘制折线图#

下面是一个简单的例子，演示如何使用 Plotters 绘制折线图：

1
use plotters::prelude::*;
2

3
fn main() -> Result<(), Box<dyn std::error::Error>> {
4
    let root = BitMapBackend::new("plot.png", (640, 480)).into_drawing_area();
5
    root.fill(&WHITE)?;
6

7
    let mut chart = ChartBuilder::on(&root)
8
        .caption("折线图", ("sans-serif", 30))
9
        .set_label_area_size(LabelAreaPosition::Left, 40)
10
        .set_label_area_size(LabelAreaPosition::Bottom, 40)
11
        .build_cartesian_2d(0..10, 0..10)?;
12

13
    chart.configure_mesh().draw()?;
14

15
    chart.draw_series(LineSeries::new(
16
        vec![(0, 0), (1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6), (7, 7), (8, 8), (9, 9)]
17
            .iter()
18
            .map(|x| (*x, *x)),
19
        &BLUE,
20
    ))?;
21

22
    Ok(())
23
}

这个例子中，我们首先创建了一个BitMapBackend对象，用于输出 PNG 格式的图片。然后，我们创建了一个ChartBuilder对象，用于构建图表。在ChartBuilder对象上，我们设置了标题、坐标轴标签和网格线。最后，我们使用LineSeries对象绘制了一条折线。LineSeries对象需要一个元组列表作为输入，每个元组包含一个 x 坐标和一个 y 坐标。在这个例子中，我们绘制了一条从(0,0)到(9,9)的折线。

绘制柱状图#

下面是一个简单的例子，演示如何使用 Plotters 绘制柱状图：

1
use plotters::prelude::*;
2

3
fn main() -> Result<(), Box<dyn std::error::Error>> {
4
    let root = BitMapBackend::new("plot.png", (640, 480)).into_drawing_area();
5
    root.fill(&WHITE)?;
6

7
    let mut chart = ChartBuilder::on(&root)
8
        .caption("柱状图", ("sans-serif", 30))
9
        .set_label_area_size(LabelAreaPosition::Left, 40)
10
        .set_label_area_size(LabelAreaPosition::Bottom, 40)
11
        .build_cartesian_2d(0..10, 0..10)?;
12

13
    chart.configure_mesh().draw()?;
14

15
    chart.draw_series(
16
        Histogram::vertical(&chart)
17
            .margin(5)
18
            .style(GREEN.filled())
19
            .data(vec![2, 3, 4, 5, 6, 7, 8, 9]),
20
    )?;
21

22
    Ok(())
23
}

这个例子中，我们首先创建了一个BitMapBackend对象，用于输出 PNG 格式的图片。然后，我们创建了一个ChartBuilder对象，用于构建图表。在ChartBuilder对象上，我们设置了标题、坐标轴标签和网格线。最后，我们使用Histogram对象绘制了一组柱状。Histogram对象需要一个整数向量作为输入，每个整数表示一个柱状的高度。在这个例子中，我们绘制了一组高度为 2 到 9 的柱状。

绘制散点图#

下面是一个简单的例子，演示如何使用 Plotters 绘制散点图：

1
use plotters::prelude::*;
2

3
fn main() -> Result<(), Box<dyn std::error::Error>> {
4
    let root = BitMapBackend::new("plot.png", (640, 480)).into_drawing_area();
5
    root.fill(&WHITE)?;
6

7
    let mut chart = ChartBuilder::on(&root)
8
        .caption("散点图", ("sans-serif", 30))
9
        .set_label_area_size(LabelAreaPosition::Left, 40)
10
        .set_label_area_size(LabelAreaPosition::Bottom, 40)
11
        .build_cartesian_2d(0..10, 0..10)?;
12

13
    chart.configure_mesh().draw()?;
14

15
    chart.draw_series(
16
        PointSeries::of_element(
17
            [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6), (7, 7), (8, 8), (9, 9)],
18
            5,
19
            &BLUE,
20
            &|c, s, st| {
21
                return EmptyElement::at(c) + Circle::new((0, 0), s, st.filled());
22
            },
23
        ),
24
    )?;
25

26
    Ok(())
27
}

这个例子中，我们首先创建了一个BitMapBackend对象，用于输出 PNG 格式的图片。然后，我们创建了一个ChartBuilder对象，用于构建图表。在ChartBuilder对象上，我们设置了标题、坐标轴标签和网格线。最后，我们使用PointSeries对象绘制了一组散点。PointSeries对象需要一个元组列表作为输入，每个元组包含一个 x 坐标和一个 y 坐标。在这个例子中，我们绘制了一组从(0,0)到(9,9)的散点。

绘制饼图#

下面是一个简单的例子，演示如何使用 Plotters 绘制饼图：

1
use plotters::prelude::*;
2

3
fn main() -> Result<(), Box<dyn std::error::Error>> {
4
    let root = BitMapBackend::new("plot.png", (640, 480)).into_drawing_area();
5
    root.fill(&WHITE)?;
6

7
    let data = vec![("A", 10), ("B", 20), ("C", 30), ("D", 40)];
8

9
    let sum = data.iter().map(|(_, v)| v).sum::<i32>() as f64;
10

11
    let mut chart = ChartBuilder::on(&root)
12
        .caption("饼图", ("sans-serif", 30))
13
        .build_ranged(0.0..1.0, 0.0..1.0)?;
14

15
    chart.draw_series(
16
        data.iter()
17
            .map(|(label, value)| {
18
                let value = *value as f64 / sum;
19
                Sector::new(
20
                    (0.5, 0.5),
21
                    value,
22
                    (0.0, 0.0),
23
                    (HSLColor(0.0, 1.0, 0.5), BLACK),
24
                )
25
                .label(label)
26
                .legend(move |(x, y)| {
27
                    Rectangle::new([(x - 5, y - 5), (x + 5, y + 5)], HSLColor(0.0, 1.0, 0.5).filled())
28
                })
29
            })
30
            .collect::<Vec<_>>(),
31
    )?;
32

33
    Ok(())
34
}

这个例子中，我们首先创建了一个BitMapBackend对象，用于输出 PNG 格式的图片。然后，我们创建了一个ChartBuilder对象，用于构建图表。在ChartBuilder对象上，我们设置了标题。最后，我们使用Sector对象绘制了一组扇形。Sector对象需要一个位置、角度、半径、颜色和标签等参数。在这个例子中，我们绘制了一组占比为 10%、20%、30%和 40%的扇形。

绘制等高线图#

下面是一个简单的例子，演示如何使用 Plotters 绘制等高线图：

1
use plotters::prelude::*;
2

3
fn main() -> Result<(), Box<dyn std::error::Error>> {
4
    let root = BitMapBackend::new("plot.png", (640, 480)).into_drawing_area();
5
    root.fill(&WHITE)?;
6

7
    let mut chart = ChartBuilder::on(&root)
8
        .caption("等高线图", ("sans-serif", 30))
9
        .set_label_area_size(LabelAreaPosition::Left, 40)
10
        .set_label_area_size(LabelAreaPosition::Bottom, 40)
11
        .build_cartesian_2d(0..10, 0..10)?;
12

13
    chart.configure_mesh().draw()?;
14

15
    let data = (0..=100).map(|i| {
16
        let x = i as f64 / 10.0;
17
        let y = i as f64 / 10.0;
18
        (x, y, (x * x + y * y).sin())
19
    });
20

21
    chart.draw_series(
22
        ContourSeries::new(
23
            data,
24
            (0..=10).map(|i| i as f64),
25
            (0..=10).map(|i| i as f64),
26
            &Palette::viridis(),
27
        )
28
        .levels(20),
29
    )?;
30

31
    Ok(())
32
}

这个例子中，我们首先创建了一个BitMapBackend对象，用于输出 PNG 格式的图片。然后，我们创建了一个ChartBuilder对象，用于构建图表。在ChartBuilder对象上，我们设置了标题、坐标轴标签和网格线。最后，我们使用ContourSeries对象绘制了一组等高线。ContourSeries对象需要一个元组列表作为输入，每个元组包含一个 x 坐标、一个 y 坐标和一个高度。在这个例子中，我们绘制了一个以(0,0)为中心的高斯分布等高线。

绘制热力图#

下面是一个简单的例子，演示如何使用 Plotters 绘制热力图：

1
use plotters::prelude::*;
2

3
fn main() -> Result<(), Box<dyn std::error::Error>> {
4
    let root = BitMapBackend::new("plot.png", (640, 480)).into_drawing_area();
5
    root.fill(&WHITE)?;
6

7
    let mut chart = ChartBuilder::on(&root)
8
        .caption("热力图", ("sans-serif", 30))
9
        .set_label_area_size(LabelAreaPosition::Left, 40)
10
        .set_label_area_size(LabelAreaPosition::Bottom, 40)
11
        .build_cartesian_2d(0..10, 0..10)?;
12

13
    chart.configure_mesh().draw()?;
14

15
    let data = (0..=100).map(|i| {
16
        let x = i as f64 / 10.0;
17
        let y = i as f64 / 10.0;
18
        (x, y, (x * x + y * y).sin())
19
    });
20

21
    chart.draw_series(
22
        Heatmap::new(data, &Palette::viridis())
23
            .x_label("X")
24
            .y_label("Y"),
25
    )?;
26

27
    Ok(())
28
}

这个例子中，我们首先创建了一个BitMapBackend对象，用于输出 PNG 格式的图片。然后，我们创建了一个ChartBuilder对象，用于构建图表。在ChartBuilder对象上，我们设置了标题、坐标轴标签和网格线。最后，我们使用Heatmap对象绘制了一个热力图。Heatmap对象需要一个元组列表作为输入，每个元组包含一个 x 坐标、一个 y 坐标和一个高度。在这个例子中，我们绘制了一个以(0,0)为中心的高斯分布热力图。

绘制箱线图#

下面是一个简单的例子，演示如何使用 Plotters 绘制箱线图：

1
use plotters::prelude::*;
2

3
fn main() -> Result<(), Box<dyn std::error::Error>> {
4
    let root = BitMapBackend::new("plot.png", (640, 480)).into_drawing_area();
5
    root.fill(&WHITE)?;
6

7
    let mut chart = ChartBuilder::on(&root)
8
        .caption("箱线图", ("sans-serif", 30))
9
        .set_label_area_size(LabelAreaPosition::Left, 40)
10
        .set_label_area_size(LabelAreaPosition::Bottom, 40)
11
        .build_cartesian_2d(0..10, 0..10)?;
12

13
    chart.configure_mesh().draw()?;
14

15
    let data = vec![
16
        ("A", vec![2, 3, 4, 5, 6, 7, 8, 9]),
17
        ("B", vec![3, 4, 5, 6, 7, 8, 9, 10]),
18
        ("C", vec![4, 5, 6, 7, 8, 9, 10, 11]),
19
        ("D", vec![5, 6, 7, 8, 9, 10, 11, 12]),
20
    ];
21

22
    chart.draw_series(
23
        data.iter()
24
            .enumerate()
25
            .map(|(i, (label, values))| {
26
                BoxPlot::new_horizontal(
27
                    values.iter().map(|&v| (v - 2) as f64),
28
                    i as f64,
29
                    &BLACK,
30
                )
31
                .label(label)
32
            })
33
            .collect::<Vec<_>>(),
34
    )?;
35

36
    Ok(())
37
}

这个例子中，我们首先创建了一个BitMapBackend对象，用于输出 PNG 格式的图片。然后，我们创建了一个ChartBuilder对象，用于构建图表。在ChartBuilder对象上，我们设置了标题、坐标轴标签和网格线。最后，我们使用BoxPlot对象绘制了一组箱线。BoxPlot对象需要一个浮点数向量作为输入，每个浮点数表示一个箱线的高度。在这个例子中，我们绘制了一组包含四个箱线的箱线图。

绘制极坐标图#

下面是一个简单的例子，演示如何使用 Plotters 绘制极坐标图：

1
use plotters::prelude::*;
2

3
fn main() -> Result<(), Box<dyn std::error::Error>> {
4
    let root = BitMapBackend::new("plot.png", (640, 480)).into_drawing_area();
5
    root.fill(&WHITE)?;
6

7
    let mut chart = ChartBuilder::on(&root)
8
        .caption("极坐标图", ("sans-serif", 30))
9
        .build_cartesian_2d(-1.2..1.2, -1.2..1.2)?;
10

11
    chart.configure_mesh().draw()?;
12

13
    chart.draw_series(LineSeries::new(
14
        (-100..=100)
15
            .map(|i| {
16
                let t = i as f64 / 100.0 * std::f64::consts::PI * 2.0;
17
                (t.cos(), t.sin())
18
            })
19
            .take(101),
20
        &RED,
21
    ))?;
22

23
    Ok(())
24
}

这个例子中，我们首先创建了一个BitMapBackend对象，用于输出 PNG 格式的图片。然后，我们创建了一个ChartBuilder对象，用于构建图表。在ChartBuilder对象上，我们设置了标题。最后，我们使用LineSeries对象绘制了一条极坐标线。LineSeries对象需要一个元组列表作为输入，每个元组包含一个角度和一个半径。在这个例子中，我们绘制了一条从 0 度到 360 度的极坐标线。

自定义样式#

1
use plotters::prelude::*;
2

3
fn main() -> Result<(), Box<dyn std::error::Error>> {
4
    let root = BitMapBackend::new("plot.png", (640, 480)).into_drawing_area();
5
    root.fill(&WHITE)?;
6

7
    let mut chart = ChartBuilder::on(&root)
8
        .caption("Custom Style Chart", ("sans-serif", 20))
9
        .x_label_area_size(30)
10
        .y_label_area_size(30)
11
        .build_cartesian_2d(0f32..10f32, 0f32..10f32)?;
12

13
    chart.configure_mesh().draw()?;
14

15
    chart
16
        .draw_series(LineSeries::new(
17
            (0..10).map(|x| (x as f32, (x as f32).powf(2.0))),
18
            &RED.stroke_width(2),
19
        ))?
20
        .label("y=x^2");
21

22
    chart
23
        .draw_series(LineSeries::new(
24
            (0..10).map(|x| (x as f32, (x as f32).powf(2.0) + 2.0)),
25
            &BLUE.stroke_width(2),
26
        ))?
27
        .label("y=x^2+2");
28

29
    chart
30
        .configure_series_labels()
31
        .background_style(&WHITE.mix(0.8))
32
        .border_style(&BLACK)
33
        .draw()?;
34

35
    Ok(())
36
}

这个示例创建了一个自定义样式的图表。我们使用stroke_width方法设置了线段的宽度，使用mix方法设置了标签的背景色。我们还使用border_style方法设置了标签的边框颜色。

使用 CSV 文件绘制线图#

下面是一个使用 CSV 文件绘制线图的示例代码：

1
use plotters::prelude::*;
2
use std::fs::File;
3
use std::io::{BufRead, BufReader};
4

5
fn main() -> Result<(), Box<dyn std::error::Error>> {
6
    let root = BitMapBackend::new("line_csv.png", (640, 480)).into_drawing_area();
7
    root.fill(&WHITE)?;
8

9
    let mut chart = ChartBuilder::on(&root)
10
        .caption("Line Chart with CSV", ("sans-serif", 40))
11
        .set_label_area_size(LabelAreaPosition::Left, 50)
12
        .set_label_area_size(LabelAreaPosition::Bottom, 50)
13
        .build_cartesian_2d(0..10, 0..10)?;
14

15
    chart.configure_mesh().draw()?;
16

17
    let file = File::open("data.csv").unwrap();
18
    let reader = BufReader::new(file);
19

20
    let data: Vec<(i32, i32)> = reader
21
        .lines()
22
        .map(|line| {
23
            let line = line.unwrap();
24
            let parts: Vec<&str> = line.split(',').collect();
25
            let x = parts[0].parse::<i32>().unwrap();
26
            let y = parts[1].parse::<i32>().unwrap();
27
            (x, y)
28
        })
29
        .collect();
30

31
    chart.draw_series(LineSeries::new(data, &RED))?;
32

33
    Ok(())
34
}

在上述代码中，我们首先创建了一个BitMapBackend对象，用于指定输出格式和大小。然后，我们创建了一个ChartBuilder对象，用于指定图表的标题和坐标轴等属性。接着，我们读取了一个名为data.csv的 CSV 文件，并将其转换为一个包含(i32, i32)元组的向量。最后，我们通过chart.draw_series方法将线图绘制到图表中。

绘制带有标签的散点图#

下面是一个绘制带有标签的散点图的示例代码：

1
use plotters::prelude::*;
2

3
fn main() -> Result<(), Box<dyn std::error::Error>> {
4
    let root = BitMapBackend::new("scatter.png", (640, 480)).into_drawing_area();
5
    root.fill(&WHITE)?;
6

7
    let mut chart = ChartBuilder::on(&root)
8
        .caption("Scatter Chart with Labels", ("sans-serif", 40))
9
        .set_label_area_size(LabelAreaPosition::Left, 50)
10
        .set_label_area_size(LabelAreaPosition::Bottom, 50)
11
        .build_cartesian_2d(0..10, 0..10)?;
12

13
    chart.configure_mesh().draw()?;
14

15
    let data = [
16
        ("A", (1, 2)),
17
        ("B", (2, 3)),
18
        ("C", (3, 4)),
19
        ("D", (4, 5)),
20
        ("E", (5, 6)),
21
    ];
22

23
    chart.draw_series(
24
        data.iter()
25
            .map(|(label, (x, y))| {
26
                Circle::new((*x, *y), 5, BLUE.filled())
27
                    .label(*label)
28
                    .legend(*label)
29
            })
30
            .collect::<Vec<_>>(),
31
    )?;
32

33
    chart
34
        .configure_series_labels()
35
        .background_style(&WHITE.mix(0.8))
36
        .border_style(&BLACK)
37
        .draw()?;
38

39
    Ok(())
40
}

在上述代码中，我们首先创建了一个BitMapBackend对象，用于指定输出格式和大小。然后，我们创建了一个ChartBuilder对象，用于指定图表的标题和坐标轴等属性。接着，我们创建了一个包含标签的散点数据，并使用Circle对象绘制散点图。最后，我们通过chart.configure_series_labels方法绘制标签。

绘制堆叠柱状图#

下面是一个绘制堆叠柱状图的示例代码：

1
use plotters::prelude::*;
2

3
fn main() -> Result<(), Box<dyn std::error::Error>> {
4
    let root = BitMapBackend::new("stacked_bar.png", (640, 480)).into_drawing_area();
5
    root.fill(&WHITE)?;
6

7
    let mut chart = ChartBuilder::on(&root)
8
        .caption("Stacked Bar Chart", ("sans-serif", 40))
9
        .set_label_area_size(LabelAreaPosition::Left, 50)
10
        .set_label_area_size(LabelAreaPosition::Bottom, 50)
11
        .build_cartesian_2d(0..10, 0..10)?;
12

13
    chart.configure_mesh().draw()?;
14

15
    let data = vec![
16
        ("A", vec![2, 3, 1, 4, 2]),
17
        ("B", vec![1, 4, 3, 2, 1]),
18
        ("C", vec![3, 2, 4, 1, 3]),
19
    ];
20

21
    chart.draw_series(
22
        data.iter()
23
            .enumerate()
24
            .map(|(i, (label, values))| {
25
                let color = Palette99::pick(i);
26
                let values = values.iter().map(|v| *v as i64).collect::<Vec<_>>();
27
                let sum = values.iter().sum::<i64>();
28
                let offset = if i == 0 { 0 } else { data[i - 1].1.iter().sum::<i32>() };
29
                let data = values.iter().enumerate().map(|(j, v)| (j as i32 + offset, *v)).collect::<Vec<_>>();
30
                BarChart::new(data, 0.5)
31
                    .style(color.filled())
32
                    .label(label)
33
                    .legend(format!("{} ({}%)", label, v as f64 / sum as f64 * 100.0))
34
            })
35
            .collect::<Vec<_>>(),
36
    )?;
37

38
    chart
39
        .configure_series_labels()
40
        .background_style(&WHITE.mix(0.8))
41
        .border_style(&BLACK)
42
        .draw()?;
43

44
    Ok(())
45
}

在上述代码中，我们首先创建了一个BitMapBackend对象，用于指定输出格式和大小。然后，我们创建了一个ChartBuilder对象，用于指定图表的标题和坐标轴等属性。接着，我们创建了一个包含堆叠柱状数据，并使用BarChart对象绘制堆叠柱状图。最后，我们通过chart.configure_series_labels方法绘制标签。

总结#

Plotters 是一个强大的绘图库，可以用于创建各种类型的图表。它提供了易于使用的 API，可以轻松地创建高质量的图表，并支持多种输出格式。在使用 Plotters 时，我们可以遵循最佳实践，以提高代码的可读性和可维护性。

音乐

音乐