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.

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(PlPath::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/contourplot.rs (line 11)

fn main() {
    let dataset = LazyCsvReader::new(PlPath::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();
}

examples/faceting.rs (line 174)

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;

    // Pattern 1: Gaussian Peak
    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 = (-x * x - y * y).exp();
            x_vals.push(x);
            y_vals.push(y);
            z_vals.push(z);
            patterns.push("Gaussian");
        }
    }

    // Pattern 2: Saddle Point
    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 = x * x - y * y;
            x_vals.push(x);
            y_vals.push(y);
            z_vals.push(z);
            patterns.push("Saddle");
        }
    }

    // Pattern 3: Ripple Effect
    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 r = (x * x + y * y).sqrt();
            let z = (r * 2.0).sin() / (r + 0.1);
            x_vals.push(x);
            y_vals.push(y);
            z_vals.push(z);
            patterns.push("Ripple");
        }
    }

    // Pattern 4: Paraboloid
    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 = x * x + y * y;
            x_vals.push(x);
            y_vals.push(y);
            z_vals.push(z);
            patterns.push("Paraboloid");
        }
    }

    // Pattern 5: Wave Interference
    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 = (x * 2.0).sin() * (y * 2.0).cos();
            x_vals.push(x);
            y_vals.push(y);
            z_vals.push(z);
            patterns.push("Wave");
        }
    }

    // Pattern 6: Diagonal Waves
    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 = ((x + y) * 2.0).sin();
            x_vals.push(x);
            y_vals.push(y);
            z_vals.push(z);
            patterns.push("Diagonal");
        }
    }

    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))
        .plot_title(Text::from("Mathematical Surface Patterns").size(16))
        .x_title(Text::from("X Axis"))
        .y_title(Text::from("Y Axis"))
        .build()
        .plot();
}

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 Serialize for ContourPlot

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 ContourPlot