Struct ScatterPolar 

pub struct ScatterPolar { /* private fields */ }

A structure representing a scatter polar plot.

The ScatterPolar struct facilitates the creation and customization of polar scatter plots with various options for data selection, grouping, layout configuration, and aesthetic adjustments. It supports grouping of data, customization of marker shapes, colors, sizes, line styles, and comprehensive layout customization including titles and legends.

Arguments

• data - A reference to the DataFrame containing the data to be plotted.
• theta - A string slice specifying the column name to be used for the angular coordinates (in degrees).
• r - A string slice specifying the column name to be used for the radial coordinates.
• group - An optional string slice specifying the column name to be used for grouping data points.
• sort_groups_by - Optional comparator fn(&str, &str) -> std::cmp::Ordering to control group ordering. Groups are sorted lexically by default.
• facet - An optional string slice specifying the column name to be used for faceting (creating multiple subplots).
• facet_config - An optional reference to a FacetConfig struct for customizing facet behavior (grid dimensions, scales, gaps, etc.).
• mode - An optional Mode specifying the drawing mode (lines, markers, or both). Defaults to markers.
• opacity - An optional f64 value specifying the opacity of the plot elements (range: 0.0 to 1.0).
• fill - An optional Fill type specifying how to fill the area under the trace.
• size - An optional usize specifying the size of the markers.
• color - An optional Rgb value specifying the color of the markers. This is used when group is not specified.
• colors - An optional vector of Rgb values specifying the colors for the markers. This is used when group is specified to differentiate between groups.
• shape - An optional Shape specifying the shape of the markers. This is used when group is not specified.
• shapes - An optional vector of Shape values specifying multiple shapes for the markers when plotting multiple groups.
• width - An optional f64 specifying the width of the lines.
• line - An optional LineStyle specifying the style of the line (e.g., solid, dashed).
• lines - An optional vector of LineStyle enums specifying the styles of lines for multiple traces.
• plot_title - An optional Text struct specifying the 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 (e.g., positioning, font, etc.).

Example

use plotlars::{Legend, Line, Mode, Plot, Rgb, ScatterPolar, Shape, Text};
use polars::prelude::*;

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

ScatterPolar::builder()
    .data(&dataset)
    .theta("angle")
    .r("score")
    .group("product")
    .mode(Mode::LinesMarkers)
    .colors(vec![
        Rgb(255, 99, 71),
        Rgb(60, 179, 113),
    ])
    .shapes(vec![
        Shape::Circle,
        Shape::Square,
    ])
    .lines(vec![
        Line::Solid,
        Line::Dash,
    ])
    .width(2.5)
    .size(8)
    .plot_title(
        Text::from("Scatter Polar Plot")
            .font("Arial")
            .size(24)
    )
    .legend_title(
        Text::from("Products")
            .font("Arial")
            .size(14)
    )
    .legend(
        &Legend::new()
            .x(0.85)
            .y(0.95)
    )
    .build()
    .plot();

Implementations

impl ScatterPolar

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

Examples found in repository

examples/scatterpolar.rs (line 32)

fn basic_scatter_polar() {
    // Create sample data - wind direction and speed
    let directions = vec![0., 45., 90., 135., 180., 225., 270., 315., 360.];
    let speeds = vec![5.0, 7.5, 10.0, 8.5, 6.0, 4.5, 3.0, 2.5, 5.0];

    let dataset = DataFrame::new(
        directions.len(),
        vec![
            Column::new("direction".into(), directions),
            Column::new("speed".into(), speeds),
        ],
    )
    .unwrap();

    ScatterPolar::builder()
        .data(&dataset)
        .theta("direction")
        .r("speed")
        .mode(Mode::Markers)
        .color(Rgb(65, 105, 225))
        .shape(Shape::Circle)
        .size(10)
        .plot_title(Text::from("Wind Speed by Direction").font("Arial").size(20))
        .build()
        .plot();
}

fn styled_scatter_polar() {
    // Create sample data - radar chart style
    let categories = vec![0., 72., 144., 216., 288., 360.];
    let performance = vec![8.0, 6.5, 7.0, 9.0, 5.5, 8.0];

    let dataset = DataFrame::new(
        categories.len(),
        vec![
            Column::new("category".into(), categories),
            Column::new("performance".into(), performance),
        ],
    )
    .unwrap();

    ScatterPolar::builder()
        .data(&dataset)
        .theta("category")
        .r("performance")
        .mode(Mode::LinesMarkers)
        .color(Rgb(255, 0, 0))
        .shape(Shape::Diamond)
        .line(Line::Solid)
        .width(3.0)
        .size(12)
        .opacity(0.8)
        .plot_title(
            Text::from("Performance Radar Chart")
                .font("Arial")
                .size(22)
                .x(0.5),
        )
        .build()
        .plot();
}

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

    ScatterPolar::builder()
        .data(&dataset)
        .theta("angle")
        .r("score")
        .group("product")
        .mode(Mode::LinesMarkers)
        .colors(vec![Rgb(255, 99, 71), Rgb(60, 179, 113)])
        .shapes(vec![Shape::Circle, Shape::Square])
        .lines(vec![Line::Solid, Line::Dash])
        .width(2.5)
        .size(8)
        .plot_title(Text::from("Product Comparison").font("Arial").size(24))
        .legend_title(Text::from("Products").font("Arial").size(14))
        .legend(&Legend::new().x(0.85).y(0.95))
        .build()
        .plot();
}

fn filled_scatter_polar() {
    // Create sample data - filled area chart
    let angles: Vec<f64> = (0..=360).step_by(10).map(|x| x as f64).collect();
    let radii: Vec<f64> = angles
        .iter()
        .map(|&angle| 5.0 + 3.0 * (angle * std::f64::consts::PI / 180.0).sin())
        .collect();

    let dataset = DataFrame::new(
        angles.len(),
        vec![
            Column::new("angle".into(), angles),
            Column::new("radius".into(), radii),
        ],
    )
    .unwrap();

    ScatterPolar::builder()
        .data(&dataset)
        .theta("angle")
        .r("radius")
        .mode(Mode::Lines)
        .fill(Fill::ToSelf)
        .color(Rgb(135, 206, 250))
        .line(Line::Solid)
        .width(2.0)
        .opacity(0.6)
        .plot_title(Text::from("Filled Polar Area Chart").font("Arial").size(20))
        .build()
        .plot();
}

examples/faceting.rs (line 565)

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

    let facet_config = FacetConfig::new()
        .highlight_facet(true)
        .unhighlighted_color(Rgb(220, 220, 220))
        .cols(3);

    ScatterPolar::builder()
        .data(&dataset)
        .theta("angle")
        .r("speed")
        .group("time")
        .facet("season")
        .facet_config(&facet_config)
        .plot_title(Text::from("Wind Patterns by Season and Time of Day"))
        .mode(Mode::LinesMarkers)
        .opacity(0.7)
        .size(7)
        .width(2.5)
        .colors(vec![Rgb(255, 105, 180), Rgb(30, 144, 255)])
        .shapes(vec![Shape::Circle, Shape::Diamond])
        .lines(vec![Line::Solid, Line::DashDot])
        .legend_title("time of day")
        .build()
        .plot();
}

examples/subplot_grid.rs (line 294)

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 ScatterPolar

fn clone(&self) -> ScatterPolar

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Serialize for ScatterPolar

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 ScatterPolar