Struct ContourPlot 

pub struct ContourPlot { /* private fields */ }

A structure representing a contour plot.

The ContourPlot struct enables the creation of contour visualizations that display level curves of a three‑dimensional surface on a two‑dimensional plane. It offers extensive configuration options for contour styling, color scaling, axis appearance, legends, and annotations. Users can fine‑tune the contour interval, choose from predefined color palettes, reverse or hide the color scale, and set custom titles for both the plot and its axes in order to improve the readability of complex surfaces.

Backend Support

Backend	Supported
Plotly	Yes
Plotters	–

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 whose magnitude determines each contour line.
• 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.).
• 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 palette (e.g., Palette::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.
• contours - An optional reference to a Contours struct for configuring the contour interval, size, and coloring.
• 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::{Coloring, ContourPlot, Palette, Plot, Text};
use polars::prelude::*;

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

ContourPlot::builder()
    .data(&dataset)
    .x("x")
    .y("y")
    .z("z")
    .color_scale(Palette::Viridis)
    .reverse_scale(true)
    .coloring(Coloring::Fill)
    .show_lines(false)
    .plot_title(
        Text::from("Contour Plot")
            .font("Arial")
            .size(18)
    )
    .build()
    .plot();

Implementations

impl ContourPlot

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

Examples found in repository

examples/plotly_contourplot.rs (line 6)

fn main() {
    let dataset = CsvReader::new("data/contour_surface.csv").finish().unwrap();

    ContourPlot::builder()
        .data(&dataset)
        .x("x")
        .y("y")
        .z("z")
        .color_scale(Palette::Viridis)
        .reverse_scale(true)
        .coloring(Coloring::Fill)
        .show_lines(false)
        .plot_title(Text::from("Contour Plot").font("Arial").size(18))
        .build()
        .plot();
}

examples/plotly_faceting.rs (line 138)

fn contourplot_example() {
    let mut x_vals = Vec::new();
    let mut y_vals = Vec::new();
    let mut z_vals = Vec::new();
    let mut patterns = Vec::new();

    let grid_size = 25;

    type SurfaceFn = Box<dyn Fn(f64, f64) -> f64>;
    let functions: Vec<(&str, SurfaceFn)> = vec![
        ("Gaussian", Box::new(|x, y| (-x * x - y * y).exp())),
        ("Saddle", Box::new(|x, y| x * x - y * y)),
        (
            "Ripple",
            Box::new(|x, y| {
                let r = (x * x + y * y).sqrt();
                (r * 2.0).sin() / (r + 0.1)
            }),
        ),
        ("Paraboloid", Box::new(|x, y| x * x + y * y)),
        ("Wave", Box::new(|x, y| (x * 2.0).sin() * (y * 2.0).cos())),
        ("Diagonal", Box::new(|x, y| ((x + y) * 2.0).sin())),
    ];

    for (name, func) in &functions {
        let mut raw_z = Vec::new();
        let mut coords = Vec::new();

        for i in 0..grid_size {
            for j in 0..grid_size {
                let x = (i as f64 - 12.0) / 3.0;
                let y = (j as f64 - 12.0) / 3.0;
                let z = func(x, y);
                raw_z.push(z);
                coords.push((x, y));
            }
        }

        // Normalize to [-1, 1]
        let z_min = raw_z.iter().cloned().fold(f64::INFINITY, f64::min);
        let z_max = raw_z.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
        let range = z_max - z_min;

        for (idx, &(x, y)) in coords.iter().enumerate() {
            let z = if range > 0.0 {
                2.0 * (raw_z[idx] - z_min) / range - 1.0
            } else {
                0.0
            };
            x_vals.push(x);
            y_vals.push(y);
            z_vals.push(z);
            patterns.push(*name);
        }
    }

    let contour_data = df! {
        "x" => x_vals,
        "y" => y_vals,
        "z" => z_vals,
        "pattern" => patterns,
    }
    .unwrap();

    ContourPlot::builder()
        .data(&contour_data)
        .x("x")
        .y("y")
        .z("z")
        .facet("pattern")
        .facet_config(&FacetConfig::new().rows(2).cols(3).scales(FacetScales::Free))
        .plot_title(Text::from("Mathematical Surface Patterns").size(16))
        .x_title(Text::from("X Axis"))
        .y_title(Text::from("Y Axis"))
        .build()
        .plot();
}

impl ContourPlot

pub fn try_new( data: &DataFrame, x: &str, y: &str, z: &str, facet: Option<&str>, facet_config: Option<&FacetConfig>, color_bar: Option<&ColorBar>, color_scale: Option<Palette>, reverse_scale: Option<bool>, show_scale: Option<bool>, show_lines: Option<bool>, coloring: Option<Coloring>, plot_title: Option<Text>, x_title: Option<Text>, y_title: Option<Text>, x_axis: Option<&Axis>, y_axis: Option<&Axis>, legend: Option<&Legend>, ) -> Result<ContourPlot, PlotlarsError>

pub fn try_builder<'f1, 'f2, 'f3, 'f4, 'f5, 'f6, 'f7, 'f8, 'f9, 'f10>() -> ContourPlotTryBuilder<'f1, 'f2, 'f3, 'f4, 'f5, 'f6, 'f7, 'f8, 'f9, 'f10>

Trait Implementations

impl Clone for ContourPlot

fn clone(&self) -> ContourPlot

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Plot for ContourPlot

fn ir_traces(&self) -> &[TraceIR]

fn ir_layout(&self) -> &LayoutIR