Struct Lighting 

pub struct Lighting {
    pub position: Option<[i32; 3]>,
    pub ambient: Option<f64>,
    pub diffuse: Option<f64>,
    pub fresnel: Option<f64>,
    pub roughness: Option<f64>,
    pub specular: Option<f64>,
}

A structure describing the lighting model.

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(xi).take(n))
    .collect::<Vec<_>>();

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

let z = x_base
    .iter()
    .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<_>>()
    })
    .flatten()
    .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)
    .lighting(
        &Lighting::new()
            .position(1, 0, 0)
            .ambient(1.0)
            .diffuse(1.0)
            .fresnel(1.0)
            .roughness(1.0)
            .specular(1.0),
    )
    .opacity(0.5)
    .build()
    .plot();

Fields

position: Option<[i32; 3]>

ambient: Option<f64>

diffuse: Option<f64>

fresnel: Option<f64>

roughness: Option<f64>

specular: Option<f64>

Implementations

impl Lighting

pub fn new() -> Lighting

Creates a new Lighting instance with default values.

Examples found in repository

examples/plotly_mesh3d.rs (line 164)

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(
        x.len(),
        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/plotly_faceting.rs (line 334)

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(
        x_vals.len(),
        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();
}

pub fn position(self, x: i32, y: i32, z: i32) -> Lighting

Sets the position of the virtual light source.

Arguments

• x – An i32 value representing the x‑coordinate of the light.
• y – An i32 value representing the y‑coordinate of the light.
• z – An i32 value representing the z‑coordinate of the light (positive z points toward the viewer).

pub fn ambient(self, value: f64) -> Lighting

Sets the ambient light component.

Arguments

• value – A f64 value in the range 0.0 – 1.0 specifying the uniform tint strength.

Examples found in repository

examples/plotly_mesh3d.rs (line 165)

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(
        x.len(),
        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/plotly_faceting.rs (line 334)

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(
        x_vals.len(),
        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();
}

pub fn diffuse(self, value: f64) -> Lighting

Sets the diffuse light component.

Arguments

• value – A f64 value in the range 0.0 – 1.0 specifying the Lambertian reflection strength.

Examples found in repository

examples/plotly_mesh3d.rs (line 166)

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(
        x.len(),
        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/plotly_faceting.rs (line 334)

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(
        x_vals.len(),
        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();
}

pub fn fresnel(self, value: f64) -> Lighting

Sets the Fresnel (edge brightness) component.

Arguments

• value – A f64 value in the range 0.0 – 1.0 specifying the rim‑light intensity.

Examples found in repository

examples/plotly_mesh3d.rs (line 169)

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(
        x.len(),
        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();
}

pub fn roughness(self, value: f64) -> Lighting

Sets the roughness of the material.

Arguments

• value – A f64 value in the range 0.0 – 1.0 that controls highlight width (0.0 = glossy, 1.0 = matte).

Examples found in repository

examples/plotly_mesh3d.rs (line 168)

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(
        x.len(),
        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();
}

pub fn specular(self, value: f64) -> Lighting

Sets the specular highlight intensity.

Arguments

• value – A f64 value in the range 0.0 – 1.0 specifying the mirror‑like highlight strength.

Examples found in repository

examples/plotly_mesh3d.rs (line 167)

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(
        x.len(),
        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/plotly_faceting.rs (line 334)

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(
        x_vals.len(),
        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 Lighting

fn clone(&self) -> Lighting

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for Lighting

fn default() -> Lighting

Returns the “default value” for a type.