Struct XYChromaticity 

pub struct XYChromaticity { /* private fields */ }

Implementations

impl XYChromaticity

pub fn plot_grid( self, x_step: f64, y_step: f64, style_attr: Option<StyleAttr>, ) -> Self

Examples found in repository

examples/xy_gamut_plots.rs (line 41)

pub fn make_plot(space: RgbSpace) -> Result<(), Box<dyn std::error::Error>> {
    let observer = Observer::Cie1931; // Use the CIE 1931 observer
                                      // let space = RgbSpace::DisplayP3; // Use the sRGB color space

    // Create an XYChromaticity chart with the specified observer and ranges
    let xy_chromaticity = XYChromaticity::new((775, 875), (-0.025..=0.75, 0.0..=0.875))
        .ticks(0.01, 0.01, 5, class("fine-grid"))
        .ticks(0.1, 0.1, 10, class("grid"))
        .x_labels(0.1, 10, None)
        .x_axis_description(&format!("{} x", observer.name()), None)
        .y_labels(0.1, 10, class("y-labels"))
        .y_axis_description(&format!("{} y", observer.name()), None)
        .plot_spectral_locus(class("spectral-locus"))
        .plot_spectral_locus_ticks(440..=650, 10, 15, class("spectral-locus-ticks"))
        .plot_spectral_locus_ticks(460..=630, 1, 7, class("spectral-locus-ticks"))
        .plot_spectral_locus_labels(460..=620, 10, 3, class("spectral-locus-labels"))
        .plot_rgb_gamut(space, None)
        .plot_planckian_locus(class("planckian"))
        .plot_planckian_locus_ticks((1500..=7500).step_by(100), 7, class("planckian-ticks-fine"))
        .plot_planckian_locus_ticks(PLANCKIAN_LABELS_AT.to_vec(), 15, class("planckian-ticks"))
        .plot_planckian_locus_labels(PLANCKIAN_LABELS_AT.to_vec(), 18, class("planckian-labels"))
        .plot_grid(0.01, 0.01, class("fine-grid"))
        .plot_grid(0.1, 0.1, class("grid"));

    // create the plot
    SvgDocument::new()
        .append_scss(STYLE)
        .add_plot(Box::new(xy_chromaticity))
        .save(format!("docs/img/{}_gamut.svg", space.as_ref().to_lowercase()).as_str())?;
    Ok(())
}

pub fn plot_poly_line( self, points: impl IntoIterator<Item = (f64, f64)>, style_attr: Option<StyleAttr>, ) -> Self

pub fn plot_shape( self, points: impl IntoIterator<Item = (f64, f64)>, style_attr: Option<StyleAttr>, ) -> Self

pub fn draw_data( self, layer: &str, data: Data, style_attr: Option<StyleAttr>, ) -> Self

pub fn draw_path( self, layer: &str, path: Path, style_attr: Option<StyleAttr>, ) -> Self

pub fn plot_image( self, image: impl Into<Image>, style_attr: Option<StyleAttr>, ) -> Self

pub fn ticks( self, x_step: f64, y_step: f64, length: i32, style_attr: Option<StyleAttr>, ) -> Self

Examples found in repository

examples/xy_gamut_plots.rs (line 26)

pub fn make_plot(space: RgbSpace) -> Result<(), Box<dyn std::error::Error>> {
    let observer = Observer::Cie1931; // Use the CIE 1931 observer
                                      // let space = RgbSpace::DisplayP3; // Use the sRGB color space

    // Create an XYChromaticity chart with the specified observer and ranges
    let xy_chromaticity = XYChromaticity::new((775, 875), (-0.025..=0.75, 0.0..=0.875))
        .ticks(0.01, 0.01, 5, class("fine-grid"))
        .ticks(0.1, 0.1, 10, class("grid"))
        .x_labels(0.1, 10, None)
        .x_axis_description(&format!("{} x", observer.name()), None)
        .y_labels(0.1, 10, class("y-labels"))
        .y_axis_description(&format!("{} y", observer.name()), None)
        .plot_spectral_locus(class("spectral-locus"))
        .plot_spectral_locus_ticks(440..=650, 10, 15, class("spectral-locus-ticks"))
        .plot_spectral_locus_ticks(460..=630, 1, 7, class("spectral-locus-ticks"))
        .plot_spectral_locus_labels(460..=620, 10, 3, class("spectral-locus-labels"))
        .plot_rgb_gamut(space, None)
        .plot_planckian_locus(class("planckian"))
        .plot_planckian_locus_ticks((1500..=7500).step_by(100), 7, class("planckian-ticks-fine"))
        .plot_planckian_locus_ticks(PLANCKIAN_LABELS_AT.to_vec(), 15, class("planckian-ticks"))
        .plot_planckian_locus_labels(PLANCKIAN_LABELS_AT.to_vec(), 18, class("planckian-labels"))
        .plot_grid(0.01, 0.01, class("fine-grid"))
        .plot_grid(0.1, 0.1, class("grid"));

    // create the plot
    SvgDocument::new()
        .append_scss(STYLE)
        .add_plot(Box::new(xy_chromaticity))
        .save(format!("docs/img/{}_gamut.svg", space.as_ref().to_lowercase()).as_str())?;
    Ok(())
}

pub fn x_labels( self, step: f64, offset: usize, style_attr: Option<StyleAttr>, ) -> Self

Examples found in repository

examples/xy_gamut_plots.rs (line 28)

pub fn make_plot(space: RgbSpace) -> Result<(), Box<dyn std::error::Error>> {
    let observer = Observer::Cie1931; // Use the CIE 1931 observer
                                      // let space = RgbSpace::DisplayP3; // Use the sRGB color space

    // Create an XYChromaticity chart with the specified observer and ranges
    let xy_chromaticity = XYChromaticity::new((775, 875), (-0.025..=0.75, 0.0..=0.875))
        .ticks(0.01, 0.01, 5, class("fine-grid"))
        .ticks(0.1, 0.1, 10, class("grid"))
        .x_labels(0.1, 10, None)
        .x_axis_description(&format!("{} x", observer.name()), None)
        .y_labels(0.1, 10, class("y-labels"))
        .y_axis_description(&format!("{} y", observer.name()), None)
        .plot_spectral_locus(class("spectral-locus"))
        .plot_spectral_locus_ticks(440..=650, 10, 15, class("spectral-locus-ticks"))
        .plot_spectral_locus_ticks(460..=630, 1, 7, class("spectral-locus-ticks"))
        .plot_spectral_locus_labels(460..=620, 10, 3, class("spectral-locus-labels"))
        .plot_rgb_gamut(space, None)
        .plot_planckian_locus(class("planckian"))
        .plot_planckian_locus_ticks((1500..=7500).step_by(100), 7, class("planckian-ticks-fine"))
        .plot_planckian_locus_ticks(PLANCKIAN_LABELS_AT.to_vec(), 15, class("planckian-ticks"))
        .plot_planckian_locus_labels(PLANCKIAN_LABELS_AT.to_vec(), 18, class("planckian-labels"))
        .plot_grid(0.01, 0.01, class("fine-grid"))
        .plot_grid(0.1, 0.1, class("grid"));

    // create the plot
    SvgDocument::new()
        .append_scss(STYLE)
        .add_plot(Box::new(xy_chromaticity))
        .save(format!("docs/img/{}_gamut.svg", space.as_ref().to_lowercase()).as_str())?;
    Ok(())
}

pub fn y_labels( self, step: f64, offset: usize, style_attr: Option<StyleAttr>, ) -> Self

Examples found in repository

examples/xy_gamut_plots.rs (line 30)

pub fn make_plot(space: RgbSpace) -> Result<(), Box<dyn std::error::Error>> {
    let observer = Observer::Cie1931; // Use the CIE 1931 observer
                                      // let space = RgbSpace::DisplayP3; // Use the sRGB color space

    // Create an XYChromaticity chart with the specified observer and ranges
    let xy_chromaticity = XYChromaticity::new((775, 875), (-0.025..=0.75, 0.0..=0.875))
        .ticks(0.01, 0.01, 5, class("fine-grid"))
        .ticks(0.1, 0.1, 10, class("grid"))
        .x_labels(0.1, 10, None)
        .x_axis_description(&format!("{} x", observer.name()), None)
        .y_labels(0.1, 10, class("y-labels"))
        .y_axis_description(&format!("{} y", observer.name()), None)
        .plot_spectral_locus(class("spectral-locus"))
        .plot_spectral_locus_ticks(440..=650, 10, 15, class("spectral-locus-ticks"))
        .plot_spectral_locus_ticks(460..=630, 1, 7, class("spectral-locus-ticks"))
        .plot_spectral_locus_labels(460..=620, 10, 3, class("spectral-locus-labels"))
        .plot_rgb_gamut(space, None)
        .plot_planckian_locus(class("planckian"))
        .plot_planckian_locus_ticks((1500..=7500).step_by(100), 7, class("planckian-ticks-fine"))
        .plot_planckian_locus_ticks(PLANCKIAN_LABELS_AT.to_vec(), 15, class("planckian-ticks"))
        .plot_planckian_locus_labels(PLANCKIAN_LABELS_AT.to_vec(), 18, class("planckian-labels"))
        .plot_grid(0.01, 0.01, class("fine-grid"))
        .plot_grid(0.1, 0.1, class("grid"));

    // create the plot
    SvgDocument::new()
        .append_scss(STYLE)
        .add_plot(Box::new(xy_chromaticity))
        .save(format!("docs/img/{}_gamut.svg", space.as_ref().to_lowercase()).as_str())?;
    Ok(())
}

pub fn x_axis_description( self, description: &str, style_attr: Option<StyleAttr>, ) -> Self

Examples found in repository

examples/xy_gamut_plots.rs (line 29)

pub fn make_plot(space: RgbSpace) -> Result<(), Box<dyn std::error::Error>> {
    let observer = Observer::Cie1931; // Use the CIE 1931 observer
                                      // let space = RgbSpace::DisplayP3; // Use the sRGB color space

    // Create an XYChromaticity chart with the specified observer and ranges
    let xy_chromaticity = XYChromaticity::new((775, 875), (-0.025..=0.75, 0.0..=0.875))
        .ticks(0.01, 0.01, 5, class("fine-grid"))
        .ticks(0.1, 0.1, 10, class("grid"))
        .x_labels(0.1, 10, None)
        .x_axis_description(&format!("{} x", observer.name()), None)
        .y_labels(0.1, 10, class("y-labels"))
        .y_axis_description(&format!("{} y", observer.name()), None)
        .plot_spectral_locus(class("spectral-locus"))
        .plot_spectral_locus_ticks(440..=650, 10, 15, class("spectral-locus-ticks"))
        .plot_spectral_locus_ticks(460..=630, 1, 7, class("spectral-locus-ticks"))
        .plot_spectral_locus_labels(460..=620, 10, 3, class("spectral-locus-labels"))
        .plot_rgb_gamut(space, None)
        .plot_planckian_locus(class("planckian"))
        .plot_planckian_locus_ticks((1500..=7500).step_by(100), 7, class("planckian-ticks-fine"))
        .plot_planckian_locus_ticks(PLANCKIAN_LABELS_AT.to_vec(), 15, class("planckian-ticks"))
        .plot_planckian_locus_labels(PLANCKIAN_LABELS_AT.to_vec(), 18, class("planckian-labels"))
        .plot_grid(0.01, 0.01, class("fine-grid"))
        .plot_grid(0.1, 0.1, class("grid"));

    // create the plot
    SvgDocument::new()
        .append_scss(STYLE)
        .add_plot(Box::new(xy_chromaticity))
        .save(format!("docs/img/{}_gamut.svg", space.as_ref().to_lowercase()).as_str())?;
    Ok(())
}

pub fn y_axis_description( self, description: &str, style_attr: Option<StyleAttr>, ) -> Self

Examples found in repository

examples/xy_gamut_plots.rs (line 31)

pub fn make_plot(space: RgbSpace) -> Result<(), Box<dyn std::error::Error>> {
    let observer = Observer::Cie1931; // Use the CIE 1931 observer
                                      // let space = RgbSpace::DisplayP3; // Use the sRGB color space

    // Create an XYChromaticity chart with the specified observer and ranges
    let xy_chromaticity = XYChromaticity::new((775, 875), (-0.025..=0.75, 0.0..=0.875))
        .ticks(0.01, 0.01, 5, class("fine-grid"))
        .ticks(0.1, 0.1, 10, class("grid"))
        .x_labels(0.1, 10, None)
        .x_axis_description(&format!("{} x", observer.name()), None)
        .y_labels(0.1, 10, class("y-labels"))
        .y_axis_description(&format!("{} y", observer.name()), None)
        .plot_spectral_locus(class("spectral-locus"))
        .plot_spectral_locus_ticks(440..=650, 10, 15, class("spectral-locus-ticks"))
        .plot_spectral_locus_ticks(460..=630, 1, 7, class("spectral-locus-ticks"))
        .plot_spectral_locus_labels(460..=620, 10, 3, class("spectral-locus-labels"))
        .plot_rgb_gamut(space, None)
        .plot_planckian_locus(class("planckian"))
        .plot_planckian_locus_ticks((1500..=7500).step_by(100), 7, class("planckian-ticks-fine"))
        .plot_planckian_locus_ticks(PLANCKIAN_LABELS_AT.to_vec(), 15, class("planckian-ticks"))
        .plot_planckian_locus_labels(PLANCKIAN_LABELS_AT.to_vec(), 18, class("planckian-labels"))
        .plot_grid(0.01, 0.01, class("fine-grid"))
        .plot_grid(0.1, 0.1, class("grid"));

    // create the plot
    SvgDocument::new()
        .append_scss(STYLE)
        .add_plot(Box::new(xy_chromaticity))
        .save(format!("docs/img/{}_gamut.svg", space.as_ref().to_lowercase()).as_str())?;
    Ok(())
}

pub fn label_pin( self, cxy: (f64, f64), r: f64, angle_and_length: (i32, i32), text: impl AsRef<str>, style_attr: Option<StyleAttr>, ) -> Self

impl XYChromaticity

pub const ANNOTATE_SEP: u32 = 2u32

pub fn new( width_and_height: (u32, u32), ranges: (impl RangeBounds<f64>, impl RangeBounds<f64>), ) -> XYChromaticity

Examples found in repository

examples/xy_gamut_plots.rs (line 25)

pub fn make_plot(space: RgbSpace) -> Result<(), Box<dyn std::error::Error>> {
    let observer = Observer::Cie1931; // Use the CIE 1931 observer
                                      // let space = RgbSpace::DisplayP3; // Use the sRGB color space

    // Create an XYChromaticity chart with the specified observer and ranges
    let xy_chromaticity = XYChromaticity::new((775, 875), (-0.025..=0.75, 0.0..=0.875))
        .ticks(0.01, 0.01, 5, class("fine-grid"))
        .ticks(0.1, 0.1, 10, class("grid"))
        .x_labels(0.1, 10, None)
        .x_axis_description(&format!("{} x", observer.name()), None)
        .y_labels(0.1, 10, class("y-labels"))
        .y_axis_description(&format!("{} y", observer.name()), None)
        .plot_spectral_locus(class("spectral-locus"))
        .plot_spectral_locus_ticks(440..=650, 10, 15, class("spectral-locus-ticks"))
        .plot_spectral_locus_ticks(460..=630, 1, 7, class("spectral-locus-ticks"))
        .plot_spectral_locus_labels(460..=620, 10, 3, class("spectral-locus-labels"))
        .plot_rgb_gamut(space, None)
        .plot_planckian_locus(class("planckian"))
        .plot_planckian_locus_ticks((1500..=7500).step_by(100), 7, class("planckian-ticks-fine"))
        .plot_planckian_locus_ticks(PLANCKIAN_LABELS_AT.to_vec(), 15, class("planckian-ticks"))
        .plot_planckian_locus_labels(PLANCKIAN_LABELS_AT.to_vec(), 18, class("planckian-labels"))
        .plot_grid(0.01, 0.01, class("fine-grid"))
        .plot_grid(0.1, 0.1, class("grid"));

    // create the plot
    SvgDocument::new()
        .append_scss(STYLE)
        .add_plot(Box::new(xy_chromaticity))
        .save(format!("docs/img/{}_gamut.svg", space.as_ref().to_lowercase()).as_str())?;
    Ok(())
}

pub fn set_observer(self, observer: Observer) -> Self

pub fn plot_spectral_locus(self, style_attr: Option<StyleAttr>) -> Self

Examples found in repository

examples/xy_gamut_plots.rs (line 32)

pub fn make_plot(space: RgbSpace) -> Result<(), Box<dyn std::error::Error>> {
    let observer = Observer::Cie1931; // Use the CIE 1931 observer
                                      // let space = RgbSpace::DisplayP3; // Use the sRGB color space

    // Create an XYChromaticity chart with the specified observer and ranges
    let xy_chromaticity = XYChromaticity::new((775, 875), (-0.025..=0.75, 0.0..=0.875))
        .ticks(0.01, 0.01, 5, class("fine-grid"))
        .ticks(0.1, 0.1, 10, class("grid"))
        .x_labels(0.1, 10, None)
        .x_axis_description(&format!("{} x", observer.name()), None)
        .y_labels(0.1, 10, class("y-labels"))
        .y_axis_description(&format!("{} y", observer.name()), None)
        .plot_spectral_locus(class("spectral-locus"))
        .plot_spectral_locus_ticks(440..=650, 10, 15, class("spectral-locus-ticks"))
        .plot_spectral_locus_ticks(460..=630, 1, 7, class("spectral-locus-ticks"))
        .plot_spectral_locus_labels(460..=620, 10, 3, class("spectral-locus-labels"))
        .plot_rgb_gamut(space, None)
        .plot_planckian_locus(class("planckian"))
        .plot_planckian_locus_ticks((1500..=7500).step_by(100), 7, class("planckian-ticks-fine"))
        .plot_planckian_locus_ticks(PLANCKIAN_LABELS_AT.to_vec(), 15, class("planckian-ticks"))
        .plot_planckian_locus_labels(PLANCKIAN_LABELS_AT.to_vec(), 18, class("planckian-labels"))
        .plot_grid(0.01, 0.01, class("fine-grid"))
        .plot_grid(0.1, 0.1, class("grid"));

    // create the plot
    SvgDocument::new()
        .append_scss(STYLE)
        .add_plot(Box::new(xy_chromaticity))
        .save(format!("docs/img/{}_gamut.svg", space.as_ref().to_lowercase()).as_str())?;
    Ok(())
}

pub fn plot_spectral_locus_ticks( self, range: impl RangeBounds<usize>, step: usize, length: usize, style_attr: Option<StyleAttr>, ) -> Self

Plots spectral locus ticks perpendicular to the spectral locus for a range for wavelengths, specficied by a start wavelength and an end wavelength, in usize units of nanometer, and with a step in nanometers.

The length parameter specifies the length of the tick lines in pixels. A positive length will draw the ticks pointing inwards, towards the white point, and negative length will draw the ticks pointing outwards, away from the white point.

Typically you will use this method multiple times to draw ticks for different ranges, and different lengths, with the finest ticks plotted first, and the coarsest ticks plotted last, plotting over the fine lines.

The style_attr parameter allows you to specify the style of the ticks, such as stroke color, width, and other SVG style attributes.

Examples found in repository

examples/xy_gamut_plots.rs (line 33)

pub fn make_plot(space: RgbSpace) -> Result<(), Box<dyn std::error::Error>> {
    let observer = Observer::Cie1931; // Use the CIE 1931 observer
                                      // let space = RgbSpace::DisplayP3; // Use the sRGB color space

    // Create an XYChromaticity chart with the specified observer and ranges
    let xy_chromaticity = XYChromaticity::new((775, 875), (-0.025..=0.75, 0.0..=0.875))
        .ticks(0.01, 0.01, 5, class("fine-grid"))
        .ticks(0.1, 0.1, 10, class("grid"))
        .x_labels(0.1, 10, None)
        .x_axis_description(&format!("{} x", observer.name()), None)
        .y_labels(0.1, 10, class("y-labels"))
        .y_axis_description(&format!("{} y", observer.name()), None)
        .plot_spectral_locus(class("spectral-locus"))
        .plot_spectral_locus_ticks(440..=650, 10, 15, class("spectral-locus-ticks"))
        .plot_spectral_locus_ticks(460..=630, 1, 7, class("spectral-locus-ticks"))
        .plot_spectral_locus_labels(460..=620, 10, 3, class("spectral-locus-labels"))
        .plot_rgb_gamut(space, None)
        .plot_planckian_locus(class("planckian"))
        .plot_planckian_locus_ticks((1500..=7500).step_by(100), 7, class("planckian-ticks-fine"))
        .plot_planckian_locus_ticks(PLANCKIAN_LABELS_AT.to_vec(), 15, class("planckian-ticks"))
        .plot_planckian_locus_labels(PLANCKIAN_LABELS_AT.to_vec(), 18, class("planckian-labels"))
        .plot_grid(0.01, 0.01, class("fine-grid"))
        .plot_grid(0.1, 0.1, class("grid"));

    // create the plot
    SvgDocument::new()
        .append_scss(STYLE)
        .add_plot(Box::new(xy_chromaticity))
        .save(format!("docs/img/{}_gamut.svg", space.as_ref().to_lowercase()).as_str())?;
    Ok(())
}

pub fn plot_spectral_locus_labels( self, range: impl RangeBounds<usize> + Clone, step: usize, distance: usize, style_attr: Option<StyleAttr>, ) -> Self

Plots spectral locus labels for the specified range of wavelengths, with a step size in nanometers.

The labels are rotated to align with the spectral locus slope at each point. The distance parameter specifies the distance from the spectral locus to the label in pixels.

The style_attr parameter allows you to specify the style of the labels,

Examples found in repository

examples/xy_gamut_plots.rs (line 35)

pub fn make_plot(space: RgbSpace) -> Result<(), Box<dyn std::error::Error>> {
    let observer = Observer::Cie1931; // Use the CIE 1931 observer
                                      // let space = RgbSpace::DisplayP3; // Use the sRGB color space

    // Create an XYChromaticity chart with the specified observer and ranges
    let xy_chromaticity = XYChromaticity::new((775, 875), (-0.025..=0.75, 0.0..=0.875))
        .ticks(0.01, 0.01, 5, class("fine-grid"))
        .ticks(0.1, 0.1, 10, class("grid"))
        .x_labels(0.1, 10, None)
        .x_axis_description(&format!("{} x", observer.name()), None)
        .y_labels(0.1, 10, class("y-labels"))
        .y_axis_description(&format!("{} y", observer.name()), None)
        .plot_spectral_locus(class("spectral-locus"))
        .plot_spectral_locus_ticks(440..=650, 10, 15, class("spectral-locus-ticks"))
        .plot_spectral_locus_ticks(460..=630, 1, 7, class("spectral-locus-ticks"))
        .plot_spectral_locus_labels(460..=620, 10, 3, class("spectral-locus-labels"))
        .plot_rgb_gamut(space, None)
        .plot_planckian_locus(class("planckian"))
        .plot_planckian_locus_ticks((1500..=7500).step_by(100), 7, class("planckian-ticks-fine"))
        .plot_planckian_locus_ticks(PLANCKIAN_LABELS_AT.to_vec(), 15, class("planckian-ticks"))
        .plot_planckian_locus_labels(PLANCKIAN_LABELS_AT.to_vec(), 18, class("planckian-labels"))
        .plot_grid(0.01, 0.01, class("fine-grid"))
        .plot_grid(0.1, 0.1, class("grid"));

    // create the plot
    SvgDocument::new()
        .append_scss(STYLE)
        .add_plot(Box::new(xy_chromaticity))
        .save(format!("docs/img/{}_gamut.svg", space.as_ref().to_lowercase()).as_str())?;
    Ok(())
}

pub fn plot_planckian_locus(self, style_attr: Option<StyleAttr>) -> Self

Examples found in repository

examples/xy_gamut_plots.rs (line 37)

pub fn make_plot(space: RgbSpace) -> Result<(), Box<dyn std::error::Error>> {
    let observer = Observer::Cie1931; // Use the CIE 1931 observer
                                      // let space = RgbSpace::DisplayP3; // Use the sRGB color space

    // Create an XYChromaticity chart with the specified observer and ranges
    let xy_chromaticity = XYChromaticity::new((775, 875), (-0.025..=0.75, 0.0..=0.875))
        .ticks(0.01, 0.01, 5, class("fine-grid"))
        .ticks(0.1, 0.1, 10, class("grid"))
        .x_labels(0.1, 10, None)
        .x_axis_description(&format!("{} x", observer.name()), None)
        .y_labels(0.1, 10, class("y-labels"))
        .y_axis_description(&format!("{} y", observer.name()), None)
        .plot_spectral_locus(class("spectral-locus"))
        .plot_spectral_locus_ticks(440..=650, 10, 15, class("spectral-locus-ticks"))
        .plot_spectral_locus_ticks(460..=630, 1, 7, class("spectral-locus-ticks"))
        .plot_spectral_locus_labels(460..=620, 10, 3, class("spectral-locus-labels"))
        .plot_rgb_gamut(space, None)
        .plot_planckian_locus(class("planckian"))
        .plot_planckian_locus_ticks((1500..=7500).step_by(100), 7, class("planckian-ticks-fine"))
        .plot_planckian_locus_ticks(PLANCKIAN_LABELS_AT.to_vec(), 15, class("planckian-ticks"))
        .plot_planckian_locus_labels(PLANCKIAN_LABELS_AT.to_vec(), 18, class("planckian-labels"))
        .plot_grid(0.01, 0.01, class("fine-grid"))
        .plot_grid(0.1, 0.1, class("grid"));

    // create the plot
    SvgDocument::new()
        .append_scss(STYLE)
        .add_plot(Box::new(xy_chromaticity))
        .save(format!("docs/img/{}_gamut.svg", space.as_ref().to_lowercase()).as_str())?;
    Ok(())
}

pub fn planckian_xy_slope_angle(&self, cct: f64) -> ((f64, f64), f64)

Calculates the slope angle of the Planckian locus at a given CCT. Returns a tuple containing the chromaticity coordinates (x, y) and the slope angle in degrees. The slope angle is the angle of the tangent to the Planckian locus in the xy chromatity chart at the specified CCT, and points left with increasing CCT. Angles in SVG are measured clockwise from the positive x-axis.

Arguments

• cct - The correlated color temperature in Kelvin.

Returns

A tuple containing the chromaticity coordinates (x, y) and the slope angle in degrees.

Example

use colorimetry_plot::chart::XYChromaticity;
let xy_chromaticity = XYChromaticity::new((800, 600), (0.0..=0.75, 0.0..=0.875));
let (xy, angle) = xy_chromaticity.planckian_xy_slope_angle(2300.0);
approx::assert_abs_diff_eq!(angle.to_degrees(), -178.0, epsilon = 0.5);
let (xy, angle) = xy_chromaticity.planckian_xy_slope_angle(6500.0);
approx::assert_abs_diff_eq!(angle.to_degrees(), -136.0, epsilon = 0.5); // Check if the angle is a finite number

pub fn planckian_uvp_normal_angle(&self, cct: f64) -> ((f64, f64), f64)

The iso-temperature lines are defined as the lines that are perpendicular to the slope of the Planckian locus at a given CCT in the CIE 1960 (u,v) chromaticity diagram, using the CIE 1931 standard observer.

References

• CIE 015:2018, “Colorimetry, 4th Edition”, Section 9.4

pub fn cct_transform(&self, cct_duv: (f64, f64)) -> Result<(f64, f64), Error>

Transform a (CCT, duv) pair to a plot point using the CIE 1931 observer.

Arguments

• cct_duv - A tuple containing the correlated color temperature (CCT) in Kelvin and the chromaticity deviation from the Planckian locus (duv).

Returns

A Result containing a tuple of the transformed chromaticity coordinates (x, y) in the plot space.

Errors

Returns an error if the CCT is invalid or cannot be converted to XYZ coordinates.

pub fn plot_ansi_step7( self, rgb_space: RgbSpace, style_attr: Option<StyleAttr>, ) -> Self

Plots the ANSI C78.377-2017 step 7 Quadrangles in the plot, filled with the color corresponding to the CCT and duv target.

pub fn planckian_xy_normal_angle(&self, cct: f64) -> ((f64, f64), f64)

Get the normal to the Planckian locus, which is perpendicular to the slope at the given CCT. Returns a tuple containing the chromaticity coordinates (x, y) and the normal angle in radians.

pub fn plot_planckian_locus_ticks( self, values: impl IntoIterator<Item = u32>, length: usize, style_attr: Option<StyleAttr>, ) -> Self

Plots the Planckian locus ticks at specified CCT values. Typically, you will use this method several times to create a nice looking scale, with different ranges and lengths. The scale if very non-linear, and requires small steps for the lower CCT values, and larger steps for the higher CCT values.

Examples found in repository

examples/xy_gamut_plots.rs (line 38)

pub fn make_plot(space: RgbSpace) -> Result<(), Box<dyn std::error::Error>> {
    let observer = Observer::Cie1931; // Use the CIE 1931 observer
                                      // let space = RgbSpace::DisplayP3; // Use the sRGB color space

    // Create an XYChromaticity chart with the specified observer and ranges
    let xy_chromaticity = XYChromaticity::new((775, 875), (-0.025..=0.75, 0.0..=0.875))
        .ticks(0.01, 0.01, 5, class("fine-grid"))
        .ticks(0.1, 0.1, 10, class("grid"))
        .x_labels(0.1, 10, None)
        .x_axis_description(&format!("{} x", observer.name()), None)
        .y_labels(0.1, 10, class("y-labels"))
        .y_axis_description(&format!("{} y", observer.name()), None)
        .plot_spectral_locus(class("spectral-locus"))
        .plot_spectral_locus_ticks(440..=650, 10, 15, class("spectral-locus-ticks"))
        .plot_spectral_locus_ticks(460..=630, 1, 7, class("spectral-locus-ticks"))
        .plot_spectral_locus_labels(460..=620, 10, 3, class("spectral-locus-labels"))
        .plot_rgb_gamut(space, None)
        .plot_planckian_locus(class("planckian"))
        .plot_planckian_locus_ticks((1500..=7500).step_by(100), 7, class("planckian-ticks-fine"))
        .plot_planckian_locus_ticks(PLANCKIAN_LABELS_AT.to_vec(), 15, class("planckian-ticks"))
        .plot_planckian_locus_labels(PLANCKIAN_LABELS_AT.to_vec(), 18, class("planckian-labels"))
        .plot_grid(0.01, 0.01, class("fine-grid"))
        .plot_grid(0.1, 0.1, class("grid"));

    // create the plot
    SvgDocument::new()
        .append_scss(STYLE)
        .add_plot(Box::new(xy_chromaticity))
        .save(format!("docs/img/{}_gamut.svg", space.as_ref().to_lowercase()).as_str())?;
    Ok(())
}

pub fn plot_planckian_locus_labels( self, values: impl IntoIterator<Item = u32>, distance: usize, style_attr: Option<StyleAttr>, ) -> Self

Plots labels for the Planckian locus at specified CCT values, divided by 100. The labels are rotated to align with the normal to the the Planckian locus at each point, centered away from the white point.

Examples found in repository

examples/xy_gamut_plots.rs (line 40)

pub fn make_plot(space: RgbSpace) -> Result<(), Box<dyn std::error::Error>> {
    let observer = Observer::Cie1931; // Use the CIE 1931 observer
                                      // let space = RgbSpace::DisplayP3; // Use the sRGB color space

    // Create an XYChromaticity chart with the specified observer and ranges
    let xy_chromaticity = XYChromaticity::new((775, 875), (-0.025..=0.75, 0.0..=0.875))
        .ticks(0.01, 0.01, 5, class("fine-grid"))
        .ticks(0.1, 0.1, 10, class("grid"))
        .x_labels(0.1, 10, None)
        .x_axis_description(&format!("{} x", observer.name()), None)
        .y_labels(0.1, 10, class("y-labels"))
        .y_axis_description(&format!("{} y", observer.name()), None)
        .plot_spectral_locus(class("spectral-locus"))
        .plot_spectral_locus_ticks(440..=650, 10, 15, class("spectral-locus-ticks"))
        .plot_spectral_locus_ticks(460..=630, 1, 7, class("spectral-locus-ticks"))
        .plot_spectral_locus_labels(460..=620, 10, 3, class("spectral-locus-labels"))
        .plot_rgb_gamut(space, None)
        .plot_planckian_locus(class("planckian"))
        .plot_planckian_locus_ticks((1500..=7500).step_by(100), 7, class("planckian-ticks-fine"))
        .plot_planckian_locus_ticks(PLANCKIAN_LABELS_AT.to_vec(), 15, class("planckian-ticks"))
        .plot_planckian_locus_labels(PLANCKIAN_LABELS_AT.to_vec(), 18, class("planckian-labels"))
        .plot_grid(0.01, 0.01, class("fine-grid"))
        .plot_grid(0.1, 0.1, class("grid"));

    // create the plot
    SvgDocument::new()
        .append_scss(STYLE)
        .add_plot(Box::new(xy_chromaticity))
        .save(format!("docs/img/{}_gamut.svg", space.as_ref().to_lowercase()).as_str())?;
    Ok(())
}

pub fn plot_rgb_gamut( self, rgb_space: RgbSpace, style_attr: Option<StyleAttr>, ) -> Self

Plots the sRGB gamut as an embeded image overlay in the plot layer. At this point, only correct colors are shown in case the RGB space is sRGB. For other color spaces, the colors are clipped to the sRGB gamut.

Examples found in repository

examples/xy_gamut_plots.rs (line 36)

pub fn make_plot(space: RgbSpace) -> Result<(), Box<dyn std::error::Error>> {
    let observer = Observer::Cie1931; // Use the CIE 1931 observer
                                      // let space = RgbSpace::DisplayP3; // Use the sRGB color space

    // Create an XYChromaticity chart with the specified observer and ranges
    let xy_chromaticity = XYChromaticity::new((775, 875), (-0.025..=0.75, 0.0..=0.875))
        .ticks(0.01, 0.01, 5, class("fine-grid"))
        .ticks(0.1, 0.1, 10, class("grid"))
        .x_labels(0.1, 10, None)
        .x_axis_description(&format!("{} x", observer.name()), None)
        .y_labels(0.1, 10, class("y-labels"))
        .y_axis_description(&format!("{} y", observer.name()), None)
        .plot_spectral_locus(class("spectral-locus"))
        .plot_spectral_locus_ticks(440..=650, 10, 15, class("spectral-locus-ticks"))
        .plot_spectral_locus_ticks(460..=630, 1, 7, class("spectral-locus-ticks"))
        .plot_spectral_locus_labels(460..=620, 10, 3, class("spectral-locus-labels"))
        .plot_rgb_gamut(space, None)
        .plot_planckian_locus(class("planckian"))
        .plot_planckian_locus_ticks((1500..=7500).step_by(100), 7, class("planckian-ticks-fine"))
        .plot_planckian_locus_ticks(PLANCKIAN_LABELS_AT.to_vec(), 15, class("planckian-ticks"))
        .plot_planckian_locus_labels(PLANCKIAN_LABELS_AT.to_vec(), 18, class("planckian-labels"))
        .plot_grid(0.01, 0.01, class("fine-grid"))
        .plot_grid(0.1, 0.1, class("grid"));

    // create the plot
    SvgDocument::new()
        .append_scss(STYLE)
        .add_plot(Box::new(xy_chromaticity))
        .save(format!("docs/img/{}_gamut.svg", space.as_ref().to_lowercase()).as_str())?;
    Ok(())
}

pub fn annotate_white_points( &mut self, point: impl IntoIterator<Item = (CieIlluminant, (i32, i32))>, ) -> &mut Self

Draw white points on the chromaticity diagram as an iterator of CieIlluminant, and i32 angle and length pairs.

Trait Implementations

impl Clone for XYChromaticity

fn clone(&self) -> XYChromaticity

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Rendable for XYChromaticity

Implements the XYChromaticity as a Rendable object, allowing it to be rendered as an SVG.

fn render(&self) -> SVG

Renders the object as an SVG element.

fn view_parameters(&self) -> ViewParameters

Returns the current view parameters for the object.

fn set_view_parameters(&mut self, view_box: ViewParameters)

Sets the view parameters for the object.

fn set_x(&mut self, x: i32)

Sets the x position of the view box (optional).

fn set_y(&mut self, y: i32)

Sets the y position of the view box (optional).

fn width(&self) -> u32

Returns the width of the view box (optional).

fn set_width(&mut self, width: u32)

Sets the width of the view box (optional).

fn height(&self) -> u32

Returns the height of the view box (optional).

fn set_height(&mut self, height: u32)

Sets the height of the view box (optional).

fn view_box(&mut self) -> (i32, i32, u32, u32)

fn set_view_box(&mut self, vx: i32, vy: i32, vw: u32, vh: u32)