Struct SurfacePlot

pub struct SurfacePlot { /* private fields */ }

A structure representing a 3-D surface plot.

The SurfacePlot struct is designed to build and customize 3-dimensional surface visualizations. It supports fine-grained control over the color mapping of z values, interactive color bars, lighting effects that enhance depth perception, and global opacity settings. Layout elements such as the plot title and axis labels can also be configured through the builder API, allowing you to embed the surface seamlessly in complex dashboards.

Arguments

• data – A reference to the DataFrame that supplies the data. It must contain three numeric columns whose names are given by x, y and z.
• x – The column name to be used for the x-axis coordinates. Each distinct x value becomes a row in the underlying z grid.
• y – The column name to be used for the y-axis coordinates. Each distinct y value becomes a column in the z grid.
• z – The column name that provides the z-axis heights. These values are mapped to colors according to color_scale / reverse_scale.
• color_bar – An optional Reference to a ColorBar describing the appearance of the color legend (length, tick formatting, border, etc.).
• color_scale – An optional Palette that defines the color gradient (e.g. Viridis, Cividis).
• reverse_scale – An optional bool indicating whether the chosen color_scale should run in the opposite direction.
• show_scale – An optional bool that toggles the visibility of the color bar. Useful when you have multiple surfaces that share an external legend.
• lighting – An optional Reference to a Lighting struct that specifies ambient, diffuse, specular components, roughness, fresnel and light position. Leaving it None applies Plotly’s default Phong shading.
• opacity – An optional f64 in [0.0, 1.0] that sets the global transparency of the surface (1 = opaque, 0 = fully transparent).
• plot_title – An optional Text that customizes the title (content, font, size, alignment).

Example

use ndarray::Array;
use plotlars::{ColorBar, Lighting, Palette, Plot, SurfacePlot, Text};
use polars::prelude::*;
use std::iter;

let n: usize = 100;
let x_base: Vec<f64> = Array::linspace(-10.0, 10.0, n).into_raw_vec();
let y_base: Vec<f64> = Array::linspace(-10.0, 10.0, n).into_raw_vec();

let x = x_base
    .iter()
    .flat_map(|&xi| iter::repeat_n(xi, n))
    .collect::<Vec<_>>();

let y = y_base
    .iter()
    .cycle()
    .take(n * n)
    .cloned()
    .collect::<Vec<_>>();

let z = x_base
    .iter()
    .flat_map(|i| {
        y_base
            .iter()
            .map(|j| 1.0 / (j * j + 5.0) * j.sin() + 1.0 / (i * i + 5.0) * i.cos())
            .collect::<Vec<_>>()
    })
    .collect::<Vec<_>>();

let dataset = df![
        "x" => &x,
        "y" => &y,
        "z" => &z,
    ]
    .unwrap();

SurfacePlot::builder()
    .data(&dataset)
    .x("x")
    .y("y")
    .z("z")
    .plot_title(
        Text::from("Surface Plot")
            .font("Arial")
            .size(18),
    )
    .color_bar(
        &ColorBar::new()
            .border_width(1),
    )
    .color_scale(Palette::Cividis)
    .reverse_scale(true)
    .opacity(0.5)
    .build()
    .plot();

Implementations

impl SurfacePlot

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

Trait Implementations

impl Clone for SurfacePlot

fn clone(&self) -> SurfacePlot

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Serialize for SurfacePlot

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

where __S: Serializer,

Serialize this value into the given Serde serializer.