Struct HeatMap 

pub struct HeatMap {
    pub traces: Vec<Box<dyn Trace + 'static>>,
    pub layout: Layout,
    /* private fields */
}

A structure representing a heat map.

The HeatMap struct enables the creation of heat map visualizations with options for color scaling, axis customization, legend adjustments, and data value formatting. Users can customize the color scale, adjust the color bar, and set titles for the plot and axes, as well as format ticks and scales for improved data readability.

Arguments

• data - A reference to the DataFrame containing the data to be plotted.
• x - A string slice specifying the column name for x-axis values.
• y - A string slice specifying the column name for y-axis values.
• z - A string slice specifying the column name for z-axis values, which are represented by the color intensity.
• 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.).
• auto_color_scale - An optional boolean for enabling automatic color scaling based on data.
• color_bar - An optional reference to a ColorBar struct for customizing the color bar appearance.
• color_scale - An optional Palette enum for specifying the color scale (e.g., Viridis).
• reverse_scale - An optional boolean to reverse the color scale direction.
• show_scale - An optional boolean to display the color scale on the plot.
• plot_title - An optional Text struct for setting the title of the plot.
• x_title - An optional Text struct for labeling the x-axis.
• y_title - An optional Text struct for labeling the y-axis.
• x_axis - An optional reference to an Axis struct for customizing x-axis appearance.
• y_axis - An optional reference to an Axis struct for customizing y-axis appearance.

Example

use plotlars::{ColorBar, HeatMap, Palette, Plot, Text, ValueExponent};
use polars::prelude::*;

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

HeatMap::builder()
    .data(&dataset)
    .x("x")
    .y("y")
    .z("z")
    .color_bar(
        &ColorBar::new()
            .length(0.7)
            .value_exponent(ValueExponent::None)
            .separate_thousands(true)
            .tick_length(5)
            .tick_step(2500.0)
    )
    .plot_title(
        Text::from("Heat Map")
            .font("Arial")
            .size(18)
    )
    .color_scale(Palette::Viridis)
    .build()
    .plot();

Fields

traces: Vec<Box<dyn Trace + 'static>>

layout: Layout

Implementations

impl HeatMap

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

Examples found in repository

examples/heatmap.rs (line 11)

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

    HeatMap::builder()
        .data(&dataset)
        .x("x")
        .y("y")
        .z("z")
        .color_bar(
            &ColorBar::new()
                .length(0.7)
                .value_exponent(ValueExponent::None)
                .separate_thousands(true)
                .tick_length(5)
                .tick_step(2500.0),
        )
        .plot_title(Text::from("Heat Map").font("Arial").size(18))
        .color_scale(Palette::Viridis)
        .build()
        .plot();
}

examples/faceting.rs (line 229)

fn heatmap_example() {
    let mut regions = Vec::new();
    let mut x_coords = Vec::new();
    let mut y_coords = Vec::new();
    let mut intensities = Vec::new();

    let region_names = ["North", "South", "East", "West"];
    let x_labels = ["X0", "X1", "X2", "X3", "X4"];
    let y_labels = ["Y0", "Y1", "Y2", "Y3", "Y4"];

    for (region_idx, region_name) in region_names.iter().enumerate() {
        for (y_idx, y_label) in y_labels.iter().enumerate() {
            for (x_idx, x_label) in x_labels.iter().enumerate() {
                regions.push(*region_name);
                x_coords.push(*x_label);
                y_coords.push(*y_label);

                let intensity = match region_idx {
                    0 => (x_idx + y_idx * 5) as f64 * 4.0,
                    1 => {
                        let dx = x_idx as f64 - 2.0;
                        let dy = y_idx as f64 - 2.0;
                        100.0 - (dx * dx + dy * dy) * 4.0
                    }
                    2 => ((x_idx * x_idx + y_idx * y_idx) as f64).sqrt() * 10.0,
                    3 => x_idx.max(y_idx) as f64 * 20.0,
                    _ => 0.0,
                };

                intensities.push(intensity);
            }
        }
    }

    let heatmap_data = df! {
        "region" => regions,
        "x" => x_coords,
        "y" => y_coords,
        "intensity" => intensities,
    }
    .unwrap();

    HeatMap::builder()
        .data(&heatmap_data)
        .x("x")
        .y("y")
        .z("intensity")
        .facet("region")
        .facet_config(&FacetConfig::new().rows(2).cols(2))
        .plot_title(Text::from("Regional Heat Intensity Patterns").size(16))
        .x_title(Text::from("X Coordinate"))
        .y_title(Text::from("Y Coordinate"))
        .build()
        .plot();
}

examples/subplot_grid.rs (line 210)

fn irregular_grid_example() {
    let dataset1 = LazyCsvReader::new(PlPath::new("data/penguins.csv"))
        .finish()
        .unwrap()
        .select([
            col("species"),
            col("sex").alias("gender"),
            col("flipper_length_mm").cast(DataType::Int16),
            col("body_mass_g").cast(DataType::Int16),
        ])
        .collect()
        .unwrap();

    let axis = Axis::new()
        .show_line(true)
        .show_grid(true)
        .value_thousands(true)
        .tick_direction(TickDirection::OutSide);

    let plot1 = Histogram::builder()
        .data(&dataset1)
        .x("body_mass_g")
        .group("species")
        .opacity(0.5)
        .colors(vec![Rgb(255, 165, 0), Rgb(147, 112, 219), Rgb(46, 139, 87)])
        .plot_title(Text::from("Histogram").x(0.0).y(1.35).size(14))
        .x_title(Text::from("body mass (g)").x(0.94).y(-0.35))
        .y_title(Text::from("count").x(-0.062).y(0.83))
        .x_axis(&axis)
        .y_axis(&axis)
        .legend_title(Text::from("species"))
        .legend(&Legend::new().x(0.87).y(1.2))
        .build();

    let dataset2 = LazyCsvReader::new(PlPath::new("data/stock_prices.csv"))
        .finish()
        .unwrap()
        .collect()
        .unwrap();

    let increasing = Direction::new()
        .line_color(Rgb(0, 200, 100))
        .line_width(0.5);

    let decreasing = Direction::new()
        .line_color(Rgb(200, 50, 50))
        .line_width(0.5);

    let plot2 = CandlestickPlot::builder()
        .data(&dataset2)
        .dates("date")
        .open("open")
        .high("high")
        .low("low")
        .close("close")
        .increasing(&increasing)
        .decreasing(&decreasing)
        .whisker_width(0.1)
        .plot_title(Text::from("Candlestick").x(0.0).y(1.35).size(14))
        .y_title(Text::from("price ($)").x(-0.06).y(0.76))
        .y_axis(&Axis::new().show_axis(true).show_grid(true))
        .build();

    let dataset3 = LazyCsvReader::new(PlPath::new("data/heatmap.csv"))
        .finish()
        .unwrap()
        .collect()
        .unwrap();

    let plot3 = HeatMap::builder()
        .data(&dataset3)
        .x("x")
        .y("y")
        .z("z")
        .color_bar(
            &ColorBar::new()
                .value_exponent(ValueExponent::None)
                .separate_thousands(true)
                .tick_length(5)
                .tick_step(5000.0),
        )
        .plot_title(Text::from("Heat Map").x(0.0).y(1.35).size(14))
        .color_scale(Palette::Viridis)
        .build();

    SubplotGrid::irregular()
        .plots(vec![
            (&plot1, 0, 0, 1, 1),
            (&plot2, 0, 1, 1, 1),
            (&plot3, 1, 0, 1, 2),
        ])
        .rows(2)
        .cols(2)
        .v_gap(0.35)
        .h_gap(0.05)
        .title(
            Text::from("Irregular Subplot Grid")
                .size(16)
                .font("Arial bold")
                .y(0.95),
        )
        .build()
        .plot();
}

Trait Implementations

impl Clone for HeatMap

fn clone(&self) -> HeatMap

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Serialize for HeatMap

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 HeatMap