Struct Mesh3D 

pub struct Mesh3D { /* private fields */ }

A structure representing a 3D mesh plot.

The Mesh3D struct is designed to create and customize 3D mesh visualizations with support for explicit triangulation, intensity-based coloring, and various lighting effects. It can handle both auto-triangulated point clouds and explicitly defined mesh connectivity through triangle indices.

Arguments

• data - A reference to the DataFrame containing the mesh data.
• x - A string slice specifying the column name for x-axis vertex coordinates.
• y - A string slice specifying the column name for y-axis vertex coordinates.
• z - A string slice specifying the column name for z-axis vertex coordinates.
• i - An optional string slice specifying the column name for first vertex indices of triangles.
• j - An optional string slice specifying the column name for second vertex indices of triangles.
• k - An optional string slice specifying the column name for third vertex indices of triangles.
• intensity - An optional string slice specifying the column name for intensity values used in gradient coloring.
• intensity_mode - An optional IntensityMode specifying whether intensity applies to vertices or cells.
• color - An optional Rgb value for uniform mesh coloring.
• color_bar - An optional reference to a ColorBar for customizing the color legend.
• color_scale - An optional Palette defining the color gradient for intensity mapping.
• reverse_scale - An optional boolean to reverse the color scale direction.
• show_scale - An optional boolean to show/hide the color bar.
• opacity - An optional f64 value specifying mesh transparency (range: 0.0 to 1.0).
• flat_shading - An optional boolean for angular (true) vs smooth (false) shading.
• lighting - An optional reference to a Lighting struct for custom lighting settings.
• light_position - An optional tuple (x, y, z) specifying the light source position.
• delaunay_axis - An optional string specifying the axis for Delaunay triangulation (“x”, “y”, or “z”).
• contour - An optional boolean to enable contour lines on the mesh.
• 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.).
• plot_title - An optional Text struct specifying the plot title.
• x_title - An optional Text struct for the x-axis title.
• y_title - An optional Text struct for the y-axis title.
• z_title - An optional Text struct for the z-axis title.
• legend - An optional reference to a Legend struct for legend customization.

Example

use plotlars::{Lighting, Mesh3D, Plot, Rgb, Text};
use polars::prelude::*;

let mut x = Vec::new();
let mut y = Vec::new();
let mut z = Vec::new();

let n = 20;
for i in 0..n {
    for j in 0..n {
        let xi = (i as f64 / (n - 1) as f64) * 2.0 - 1.0;
        let yj = (j as f64 / (n - 1) as f64) * 2.0 - 1.0;
        x.push(xi);
        y.push(yj);
        z.push(0.3 * ((xi * 3.0).sin() + (yj * 3.0).cos()));
    }
}

let dataset = DataFrame::new(vec![
    Column::new("x".into(), x),
    Column::new("y".into(), y),
    Column::new("z".into(), z),
])
.unwrap();

Mesh3D::builder()
    .data(&dataset)
    .x("x")
    .y("y")
    .z("z")
    .color(Rgb(200, 200, 255))
    .lighting(
        &Lighting::new()
            .ambient(0.5)
            .diffuse(0.8)
            .specular(0.5)
            .roughness(0.2)
            .fresnel(0.2),
    )
    .light_position((1, 1, 2))
    .opacity(1.0)
    .flat_shading(false)
    .contour(true)
    .plot_title(
        Text::from("Mesh 3D Plot")
            .font("Arial")
            .size(22),
    )
    .build()
    .plot();

Implementations

impl Mesh3D

pub fn builder<'f1, 'f2, 'f3, 'f4, 'f5, 'f6, 'f7, 'f8, 'f9, 'f10, 'f11, 'f12, 'f13, 'f14>() -> Mesh3DBuilder<'f1, 'f2, 'f3, 'f4, 'f5, 'f6, 'f7, 'f8, 'f9, 'f10, 'f11, 'f12, 'f13, 'f14>

Examples found in repository

examples/mesh3d.rs (line 23)

fn example_basic_mesh() {
    let x = vec![0.0, 1.0, 2.0, 0.0, 1.0, 2.0];
    let y = vec![0.0, 0.0, 0.0, 1.0, 1.0, 1.0];
    let z = vec![0.0, 0.5, 0.0, 0.0, 0.8, 0.0];

    let dataset = DataFrame::new(vec![
        Column::new("x".into(), x),
        Column::new("y".into(), y),
        Column::new("z".into(), z),
    ])
    .unwrap();

    Mesh3D::builder()
        .data(&dataset)
        .x("x")
        .y("y")
        .z("z")
        .color(Rgb(100, 150, 200))
        .opacity(0.8)
        .plot_title("Basic Mesh3D")
        .build()
        .plot();
}

fn example_with_indices() {
    let x = vec![0.0, 1.0, 0.5, 0.5];
    let y = vec![0.0, 0.0, 0.866, 0.289];
    let z = vec![0.0, 0.0, 0.0, 0.816];
    let i = vec![0, 0, 0, 1];
    let j = vec![1, 2, 3, 2];
    let k = vec![2, 3, 1, 3];

    let dataset = DataFrame::new(vec![
        Column::new("x".into(), x),
        Column::new("y".into(), y),
        Column::new("z".into(), z),
        Column::new("i".into(), i),
        Column::new("j".into(), j),
        Column::new("k".into(), k),
    ])
    .unwrap();

    Mesh3D::builder()
        .data(&dataset)
        .x("x")
        .y("y")
        .z("z")
        .i("i")
        .j("j")
        .k("k")
        .color(Rgb(255, 100, 100))
        .opacity(0.9)
        .flat_shading(true)
        .plot_title("Tetrahedron with Explicit Indices")
        .build()
        .plot();
}

fn example_with_intensity() {
    let mut x = Vec::new();
    let mut y = Vec::new();
    let mut z = Vec::new();
    let mut intensity = Vec::new();

    for i in 0..10 {
        for j in 0..10 {
            let xi = i as f64 * 0.1;
            let yj = j as f64 * 0.1;
            x.push(xi);
            y.push(yj);
            z.push(
                (xi * 2.0 * std::f64::consts::PI).sin()
                    * (yj * 2.0 * std::f64::consts::PI).cos()
                    * 0.3,
            );
            intensity.push(xi * yj);
        }
    }

    let dataset = DataFrame::new(vec![
        Column::new("x".into(), x),
        Column::new("y".into(), y),
        Column::new("z".into(), z),
        Column::new("intensity".into(), intensity),
    ])
    .unwrap();

    Mesh3D::builder()
        .data(&dataset)
        .x("x")
        .y("y")
        .z("z")
        .intensity("intensity")
        .intensity_mode(IntensityMode::Vertex)
        .color_scale(Palette::Viridis)
        .reverse_scale(false)
        .show_scale(true)
        .color_bar(&ColorBar::new().x(0.85).title("Intensity"))
        .opacity(0.95)
        .plot_title(
            Text::from("Mesh3D with Intensity Coloring")
                .font("Arial")
                .size(20),
        )
        .build()
        .plot();
}

fn example_with_lighting() {
    // Create a simple wavy surface mesh without explicit indices
    // The mesh will be auto-triangulated
    let mut x = Vec::new();
    let mut y = Vec::new();
    let mut z = Vec::new();

    let n = 20;
    for i in 0..n {
        for j in 0..n {
            let xi = (i as f64 / (n - 1) as f64) * 2.0 - 1.0;
            let yj = (j as f64 / (n - 1) as f64) * 2.0 - 1.0;
            x.push(xi);
            y.push(yj);
            // Create a wavy surface
            z.push(0.3 * ((xi * 3.0).sin() + (yj * 3.0).cos()));
        }
    }

    let dataset = DataFrame::new(vec![
        Column::new("x".into(), x),
        Column::new("y".into(), y),
        Column::new("z".into(), z),
    ])
    .unwrap();

    Mesh3D::builder()
        .data(&dataset)
        .x("x")
        .y("y")
        .z("z")
        .color(Rgb(200, 200, 255))
        .lighting(
            &Lighting::new()
                .ambient(0.5)
                .diffuse(0.8)
                .specular(0.5)
                .roughness(0.2)
                .fresnel(0.2),
        )
        .light_position((1, 1, 2))
        .opacity(1.0)
        .flat_shading(false)
        .contour(true)
        .plot_title(Text::from("Mesh 3D").font("Arial").size(22))
        .build()
        .plot();
}

examples/faceting.rs (line 374)

fn mesh3d_example() {
    let mut x_vals = Vec::new();
    let mut y_vals = Vec::new();
    let mut z_vals = Vec::new();
    let mut surface_type = Vec::new();

    let n = 25;

    for surface in ["Gaussian", "Saddle", "Ripple"].iter() {
        for i in 0..n {
            for j in 0..n {
                let x = (i as f64 / (n - 1) as f64) * 4.0 - 2.0;
                let y = (j as f64 / (n - 1) as f64) * 4.0 - 2.0;

                let z = match *surface {
                    "Gaussian" => (-0.5 * (x * x + y * y)).exp(),
                    "Saddle" => 0.3 * (x * x - y * y),
                    "Ripple" => 0.4 * ((x * 3.0).sin() + (y * 3.0).cos()),
                    _ => 0.0,
                };

                x_vals.push(x);
                y_vals.push(y);
                z_vals.push(z);
                surface_type.push(surface.to_string());
            }
        }
    }

    let dataset = DataFrame::new(vec![
        Column::new("x".into(), x_vals),
        Column::new("y".into(), y_vals),
        Column::new("z".into(), z_vals),
        Column::new("surface_type".into(), surface_type),
    ])
    .unwrap();

    let config = FacetConfig::new().cols(3).rows(1);

    let lighting = Lighting::new().ambient(0.6).diffuse(0.8).specular(0.4);

    Mesh3D::builder()
        .data(&dataset)
        .x("x")
        .y("y")
        .z("z")
        .facet("surface_type")
        .facet_config(&config)
        .color(Rgb(100, 150, 200))
        .lighting(&lighting)
        .plot_title(
            Text::from("Mathematical Surfaces Comparison")
                .font("Arial")
                .size(20),
        )
        .build()
        .plot();
}

Trait Implementations

impl Clone for Mesh3D

fn clone(&self) -> Mesh3D

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Serialize for Mesh3D

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 Mesh3D