Struct SankeyDiagram 

pub struct SankeyDiagram { /* private fields */ }

A structure representing a Sankey diagram.

The SankeyDiagram struct enables the creation of Sankey diagrams, which visualize flows between discrete nodes with link widths proportional to the magnitude of the flow. It offers extensive configuration options for flow orientation, node arrangement, spacing, thickness, and coloring, as well as axis and title customization. Users can specify a single uniform color or per-item colors for both nodes and links, adjust padding between nodes, set node thickness, and supply custom titles and axis labels to produce clear, publication-quality flow visualizations. Faceting support allows creating multiple Sankey diagrams in a grid layout for comparing flows across categories.

Arguments

• data – A reference to the DataFrame containing the data to be plotted.
• sources – A string slice naming the column in data that contains the source node for each flow.
• targets – A string slice naming the column in data that contains the target node for each flow.
• values – A string slice naming the column in data that contains the numeric value of each flow.
• facet – An optional string slice naming the column in data to be used for creating facets (small multiples).
• facet_config – An optional reference to a FacetConfig struct for customizing facet layout and behavior.
• orientation – An optional Orientation enum to set the overall direction of the diagram (e.g. Orientation::Horizontal or Orientation::Vertical).
• arrangement – An optional Arrangement enum to choose the node-layout algorithm (e.g. Arrangement::Snap, Arrangement::Perpendicular, etc.).
• pad – An optional usize specifying the padding (in pixels) between adjacent nodes.
• thickness – An optional usize defining the uniform thickness (in pixels) of all nodes.
• node_color – An optional Rgb value to apply a single uniform color to every node.
• node_colors – An optional Vec<Rgb> supplying individual colors for each node in order.
• link_color – An optional Rgb value to apply a single uniform color to every link.
• link_colors – An optional Vec<Rgb> supplying individual colors for each link in order.
• plot_title – An optional Text struct for setting the overall title of the plot.
• legend_title – An optional Text struct specifying the title of the legend.
• legend – An optional reference to a Legend struct for customizing the legend of the plot.

Example

use plotlars::{Arrangement, SankeyDiagram, Orientation, Plot, Rgb, Text};
use polars::prelude::*;

let dataset = LazyCsvReader::new(PlRefPath::new("data/sankey_flow.csv"))
    .finish()
    .unwrap()
    .collect()
    .unwrap();

SankeyDiagram::builder()
    .data(&dataset)
    .sources("source")
    .targets("target")
    .values("value")
    .orientation(Orientation::Horizontal)
    .arrangement(Arrangement::Freeform)
    .node_colors(vec![
        Rgb(222, 235, 247),
        Rgb(198, 219, 239),
        Rgb(158, 202, 225),
        Rgb(107, 174, 214),
        Rgb( 66, 146, 198),
        Rgb( 33, 113, 181),
    ])
    .link_colors(vec![
        Rgb(222, 235, 247),
        Rgb(198, 219, 239),
        Rgb(158, 202, 225),
        Rgb(107, 174, 214),
        Rgb( 66, 146, 198),
        Rgb( 33, 113, 181),
    ])
    .pad(20)
    .thickness(30)
    .plot_title(
        Text::from("Sankey Diagram")
            .font("Arial")
            .size(18)
    )
    .build()
    .plot();

Implementations

impl SankeyDiagram

pub fn builder<'f1, 'f2, 'f3, 'f4, 'f5, 'f6, 'f7>() -> SankeyDiagramBuilder<'f1, 'f2, 'f3, 'f4, 'f5, 'f6, 'f7>

Examples found in repository

examples/sankeydiagram.rs (line 11)

fn main() {
    let dataset = LazyCsvReader::new(PlRefPath::new("data/sankey_flow.csv"))
        .finish()
        .unwrap()
        .collect()
        .unwrap();

    SankeyDiagram::builder()
        .data(&dataset)
        .sources("source")
        .targets("target")
        .values("value")
        .orientation(Orientation::Horizontal)
        .arrangement(Arrangement::Freeform)
        .node_colors(vec![
            Rgb(222, 235, 247),
            Rgb(198, 219, 239),
            Rgb(158, 202, 225),
            Rgb(107, 174, 214),
            Rgb(66, 146, 198),
            Rgb(33, 113, 181),
        ])
        .link_colors(vec![
            Rgb(222, 235, 247),
            Rgb(198, 219, 239),
            Rgb(158, 202, 225),
            Rgb(107, 174, 214),
            Rgb(66, 146, 198),
            Rgb(33, 113, 181),
        ])
        .pad(20)
        .thickness(30)
        .plot_title(Text::from("Sankey Diagram").font("Arial").size(18))
        .build()
        .plot();
}

examples/faceting.rs (line 461)

fn sankeydiagram_example() {
    let dataset = CsvReadOptions::default()
        .with_has_header(true)
        .try_into_reader_with_file_path(Some("data/energy_transition.csv".into()))
        .unwrap()
        .finish()
        .unwrap();

    let facet_config = FacetConfig::new()
        .cols(4)
        .h_gap(0.06)
        .title_style(Text::from("").size(11).color(Rgb(50, 50, 50)));

    let node_colors = vec![
        Rgb(64, 64, 64),
        Rgb(100, 149, 237),
        Rgb(139, 69, 19),
        Rgb(255, 195, 0),
        Rgb(135, 206, 250),
        Rgb(65, 105, 225),
        Rgb(220, 20, 60),
        Rgb(34, 139, 34),
    ];

    let link_colors = vec![
        Rgb(220, 220, 220),
        Rgb(200, 220, 245),
        Rgb(220, 200, 180),
        Rgb(255, 240, 200),
        Rgb(220, 240, 255),
        Rgb(200, 220, 240),
    ];

    SankeyDiagram::builder()
        .data(&dataset)
        .sources("source")
        .targets("target")
        .values("value")
        .facet("year")
        .facet_config(&facet_config)
        .node_colors(node_colors)
        .link_colors(link_colors)
        .arrangement(Arrangement::Perpendicular)
        .plot_title(
            Text::from("Energy Transition Timeline (2020-2023)")
                .font("Arial")
                .size(16),
        )
        .pad(18)
        .thickness(22)
        .build()
        .plot();
}

examples/subplot_grid.rs (line 312)

fn mixed_grid_example() {
    // 2D cartesian scatter (baseline)
    let penguins = LazyCsvReader::new(PlRefPath::new("data/penguins.csv"))
        .finish()
        .unwrap()
        .collect()
        .unwrap()
        .lazy()
        .select([
            col("species"),
            col("bill_length_mm"),
            col("flipper_length_mm"),
            col("body_mass_g"),
        ])
        .collect()
        .unwrap();

    let scatter_2d = ScatterPlot::builder()
        .data(&penguins)
        .x("bill_length_mm")
        .y("flipper_length_mm")
        .group("species")
        .opacity(0.65)
        .size(10)
        .plot_title(Text::from("Penguins 2D").y(1.3))
        .build();

    // 3D scene subplot
    let scatter_3d = Scatter3dPlot::builder()
        .data(&penguins)
        .x("bill_length_mm")
        .y("flipper_length_mm")
        .z("body_mass_g")
        .group("species")
        .opacity(0.35)
        .size(6)
        .plot_title(Text::from("Penguins 3D").y(1.45))
        .build();

    // Polar subplot
    let polar_df = LazyCsvReader::new(PlRefPath::new("data/product_comparison_polar.csv"))
        .finish()
        .unwrap()
        .collect()
        .unwrap();

    let polar = ScatterPolar::builder()
        .data(&polar_df)
        .theta("angle")
        .r("score")
        .group("product")
        .mode(Mode::LinesMarkers)
        .size(10)
        .plot_title(Text::from("Product Comparison (Polar)").y(1.5).x(0.72))
        .legend(&Legend::new().x(0.8))
        .build();

    // Domain-based subplot (Sankey)
    let sankey_df = LazyCsvReader::new(PlRefPath::new("data/energy_transition.csv"))
        .finish()
        .unwrap()
        .collect()
        .unwrap();

    let sankey = SankeyDiagram::builder()
        .data(&sankey_df)
        .sources("source")
        .targets("target")
        .values("value")
        .orientation(Orientation::Horizontal)
        .arrangement(Arrangement::Freeform)
        .plot_title(Text::from("Energy Flow").y(1.2))
        .build();

    // Mapbox subplot
    let map_df = LazyCsvReader::new(PlRefPath::new("data/cities.csv"))
        .finish()
        .unwrap()
        .collect()
        .unwrap();

    let scatter_map = ScatterMap::builder()
        .data(&map_df)
        .latitude("latitude")
        .longitude("longitude")
        .group("city")
        .zoom(4)
        .center([50.0, 5.0])
        .opacity(0.8)
        .plot_title(Text::from("Cities (Mapbox)").y(1.2))
        .build();

    // Geo subplot
    let geo_df = LazyCsvReader::new(PlRefPath::new("data/world_cities.csv"))
        .finish()
        .unwrap()
        .collect()
        .unwrap();

    let scatter_geo = ScatterGeo::builder()
        .data(&geo_df)
        .lat("lat")
        .lon("lon")
        .group("continent")
        .mode(Mode::Markers)
        .size(10)
        .color(Rgb(255, 140, 0))
        .shape(Shape::Circle)
        .plot_title(Text::from("Global Cities (Geo)").x(0.65).y(1.2))
        .legend(&Legend::new().x(0.8))
        .build();

    SubplotGrid::regular()
        .plots(vec![
            &scatter_2d,
            &scatter_3d,
            &polar,
            &sankey,
            &scatter_map,
            &scatter_geo,
        ])
        .rows(2)
        .cols(3)
        .h_gap(0.12)
        .v_gap(0.22)
        .title(
            Text::from("Mixed Subplot Grid")
                .size(16)
                .font("Arial bold")
                .y(0.95),
        )
        .build()
        .plot();
}

Trait Implementations

impl Clone for SankeyDiagram

fn clone(&self) -> SankeyDiagram

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Serialize for SankeyDiagram

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl PlotHelper for SankeyDiagram