Struct ColorBar 

pub struct ColorBar { /* private fields */ }

A structure representing a color bar component for visualizations.

Example

use polars::prelude::*;
use plotlars::{ColorBar, HeatMap, Orientation, Palette, Plot, Text, ValueExponent};

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

HeatMap::builder()
    .data(&dataset)
    .x("x")
    .y("y")
    .z("z")
    .color_bar(
        &ColorBar::new()
            .orientation(Orientation::Horizontal)
            .length(290)
            .value_exponent(ValueExponent::None)
            .separate_thousands(true)
            .tick_length(5)
            .tick_step(2500.0)
            .tick_angle(90.0)
            .y(-0.6)
    )
    .color_scale(Palette::Viridis)
    .build()
    .plot();

Implementations

impl ColorBar

pub fn new() -> Self

Creates a new ColorBar instance with default settings.

Examples found in repository

examples/heatmap.rs (line 18)

fn main() {
    let dataset = LazyCsvReader::new(PlPath::new("data/heatmap.csv"))
        .finish()
        .unwrap()
        .collect()
        .unwrap();

    HeatMap::builder()
        .data(&dataset)
        .x("x")
        .y("y")
        .z("z")
        .color_bar(
            &ColorBar::new()
                .length(290)
                .value_exponent(ValueExponent::None)
                .separate_thousands(true)
                .tick_length(5)
                .tick_step(2500.0),
        )
        .plot_title(Text::from("Heat Map").font("Arial").size(18))
        .color_scale(Palette::Viridis)
        .build()
        .plot();
}

examples/mesh3d.rs (line 109)

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) // Move color bar very close to the plot
                .title("Intensity"),
        )
        .opacity(0.95)
        .plot_title(
            Text::from("Mesh3D with Intensity Coloring")
                .font("Arial")
                .size(20),
        )
        .build()
        .plot();
}

examples/surfaceplot.rs (line 50)

fn main() {
    let n: usize = 100;
    let (x_base, _): (Vec<f64>, Option<usize>) =
        Array::linspace(-10., 10., n).into_raw_vec_and_offset();
    let (y_base, _): (Vec<f64>, Option<usize>) =
        Array::linspace(-10., 10., n).into_raw_vec_and_offset();

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

pub fn background_color(self, color: Rgb) -> Self

Sets the background color of the color bar.

Arguments

• color - An Rgb value representing the desired background color.

pub fn border_color(self, color: Rgb) -> Self

Sets the border color of the color bar.

Arguments

• color - An Rgb value representing the desired border color.

pub fn border_width(self, width: usize) -> Self

Sets the width of the color bar’s border.

Arguments

• width - A usize value specifying the border width in pixels.

Examples found in repository

examples/surfaceplot.rs (line 50)

fn main() {
    let n: usize = 100;
    let (x_base, _): (Vec<f64>, Option<usize>) =
        Array::linspace(-10., 10., n).into_raw_vec_and_offset();
    let (y_base, _): (Vec<f64>, Option<usize>) =
        Array::linspace(-10., 10., n).into_raw_vec_and_offset();

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

pub fn tick_step(self, step: f64) -> Self

Sets the step size between ticks on the color bar.

Arguments

• step - A f64 value representing the step size between ticks.

Examples found in repository

examples/heatmap.rs (line 23)

fn main() {
    let dataset = LazyCsvReader::new(PlPath::new("data/heatmap.csv"))
        .finish()
        .unwrap()
        .collect()
        .unwrap();

    HeatMap::builder()
        .data(&dataset)
        .x("x")
        .y("y")
        .z("z")
        .color_bar(
            &ColorBar::new()
                .length(290)
                .value_exponent(ValueExponent::None)
                .separate_thousands(true)
                .tick_length(5)
                .tick_step(2500.0),
        )
        .plot_title(Text::from("Heat Map").font("Arial").size(18))
        .color_scale(Palette::Viridis)
        .build()
        .plot();
}

pub fn value_exponent(self, exponent: ValueExponent) -> Self

Sets the exponent format for values on the axis.

Argument

• exponent - A ValueExponent enum value representing the exponent format.

Examples found in repository

examples/heatmap.rs (line 20)

fn main() {
    let dataset = LazyCsvReader::new(PlPath::new("data/heatmap.csv"))
        .finish()
        .unwrap()
        .collect()
        .unwrap();

    HeatMap::builder()
        .data(&dataset)
        .x("x")
        .y("y")
        .z("z")
        .color_bar(
            &ColorBar::new()
                .length(290)
                .value_exponent(ValueExponent::None)
                .separate_thousands(true)
                .tick_length(5)
                .tick_step(2500.0),
        )
        .plot_title(Text::from("Heat Map").font("Arial").size(18))
        .color_scale(Palette::Viridis)
        .build()
        .plot();
}

pub fn length(self, length: usize) -> Self

Sets the length of the color bar.

Arguments

• length - A usize value specifying the length in pixels.

Examples found in repository

examples/heatmap.rs (line 19)

fn main() {
    let dataset = LazyCsvReader::new(PlPath::new("data/heatmap.csv"))
        .finish()
        .unwrap()
        .collect()
        .unwrap();

    HeatMap::builder()
        .data(&dataset)
        .x("x")
        .y("y")
        .z("z")
        .color_bar(
            &ColorBar::new()
                .length(290)
                .value_exponent(ValueExponent::None)
                .separate_thousands(true)
                .tick_length(5)
                .tick_step(2500.0),
        )
        .plot_title(Text::from("Heat Map").font("Arial").size(18))
        .color_scale(Palette::Viridis)
        .build()
        .plot();
}

pub fn n_ticks(self, n: usize) -> Self

Sets the number of ticks on the color bar.

Arguments

• n - A usize value representing the number of ticks.

pub fn orientation(self, orientation: Orientation) -> Self

Sets the orientation of the color bar.

Arguments

• orientation - An Orientation enum value specifying the orientation (e.g., horizontal or vertical).

pub fn outline_color(self, color: Rgb) -> Self

Sets the outline color of the color bar.

Arguments

• color - An Rgb value representing the desired outline color.

pub fn outline_width(self, width: usize) -> Self

Sets the outline width of the color bar.

Arguments

• width - A usize value specifying the outline width in pixels.

pub fn separate_thousands(self, separate_thousands: bool) -> Self

Specifies whether to separate thousands in tick labels.

Arguments

• separate_thousands - A bool indicating whether to separate thousands.

Examples found in repository

examples/heatmap.rs (line 21)

fn main() {
    let dataset = LazyCsvReader::new(PlPath::new("data/heatmap.csv"))
        .finish()
        .unwrap()
        .collect()
        .unwrap();

    HeatMap::builder()
        .data(&dataset)
        .x("x")
        .y("y")
        .z("z")
        .color_bar(
            &ColorBar::new()
                .length(290)
                .value_exponent(ValueExponent::None)
                .separate_thousands(true)
                .tick_length(5)
                .tick_step(2500.0),
        )
        .plot_title(Text::from("Heat Map").font("Arial").size(18))
        .color_scale(Palette::Viridis)
        .build()
        .plot();
}

pub fn width(self, width: usize) -> Self

Sets the width of the color bar.

Arguments

• width - A usize value specifying the width in pixels.

pub fn tick_angle(self, angle: f64) -> Self

Sets the angle of the tick labels on the color bar.

Arguments

• angle - A f64 value representing the angle in degrees.

pub fn tick_color(self, color: Rgb) -> Self

Sets the color of the ticks on the color bar.

Arguments

• color - An Rgb value representing the tick color.

pub fn tick_font(self, font: impl Into<String>) -> Self

Sets the font of the tick labels on the color bar.

Arguments

• font - A string representing the font family.

pub fn tick_length(self, length: usize) -> Self

Sets the length of the axis ticks.

Argument

• length - A usize value representing the length of the ticks.

Examples found in repository

examples/heatmap.rs (line 22)

fn main() {
    let dataset = LazyCsvReader::new(PlPath::new("data/heatmap.csv"))
        .finish()
        .unwrap()
        .collect()
        .unwrap();

    HeatMap::builder()
        .data(&dataset)
        .x("x")
        .y("y")
        .z("z")
        .color_bar(
            &ColorBar::new()
                .length(290)
                .value_exponent(ValueExponent::None)
                .separate_thousands(true)
                .tick_length(5)
                .tick_step(2500.0),
        )
        .plot_title(Text::from("Heat Map").font("Arial").size(18))
        .color_scale(Palette::Viridis)
        .build()
        .plot();
}

pub fn tick_labels(self, labels: Vec<impl Into<String>>) -> Self

Sets the tick labels for the axis.

Argument

• labels - A vector of values that can be converted into String, representing the tick labels.

pub fn tick_values(self, values: Vec<f64>) -> Self

Sets the tick values for the axis.

Argument

• values - A vector of f64 values representing the tick values.

pub fn tick_width(self, width: usize) -> Self

Sets the width of the ticks on the color bar.

Arguments

• width - A usize value specifying the tick width in pixels.

pub fn tick_direction(self, direction: TickDirection) -> Self

Sets the direction of the axis ticks.

Argument

• direction - A TickDirection enum value representing the direction of the ticks.

pub fn title<T: Into<Text>>(self, title: T) -> Self

Sets the title of the color bar.

Arguments

• title - A value that can be converted into Text, representing the title.

Examples found in repository

examples/mesh3d.rs (line 111)

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) // Move color bar very close to the plot
                .title("Intensity"),
        )
        .opacity(0.95)
        .plot_title(
            Text::from("Mesh3D with Intensity Coloring")
                .font("Arial")
                .size(20),
        )
        .build()
        .plot();
}

pub fn x(self, x: f64) -> Self

Sets the x-coordinate position of the text.

Argument

• x - A f64 value specifying the horizontal position.

Examples found in repository

examples/mesh3d.rs (line 110)

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) // Move color bar very close to the plot
                .title("Intensity"),
        )
        .opacity(0.95)
        .plot_title(
            Text::from("Mesh3D with Intensity Coloring")
                .font("Arial")
                .size(20),
        )
        .build()
        .plot();
}

pub fn y(self, y: f64) -> Self

Sets the y-coordinate position of the text.

Argument

• y - A f64 value specifying the vertical position.

Trait Implementations

impl Clone for ColorBar

fn clone(&self) -> ColorBar

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for ColorBar

fn default() -> ColorBar

Returns the “default value” for a type.