Struct scarlet::colors::cielchuvcolor::CIELCHuvColor

pub struct CIELCHuvColor {
    pub l: f64,
    pub c: f64,
    pub h: f64,
}

The polar version of CIELUV, analogous to the relationship between CIELCH and CIELAB. Sometimes referred to as CIEHCL, but Scarlet uses CIELCHuv to be explicit and avoid any confusion, as well as keep consistency: in every hue-saturation-value color space or any variation of it, the coordinates are listed in the exact same order.

Example

// hue-shift red to yellow, keeping same brightness: really ends up to be brown
let red = RGBColor{r: 0.7, g: 0.1, b: 0.1};
let red_lch: CIELCHuvColor = red.convert();
let mut yellow = red_lch;
yellow.h = yellow.h + 60.;
println!("{}", red.to_string());
println!("{}", yellow.convert::<RGBColor>().to_string());
println!("{:?}", yellow);
// prints #B31A1A
//        #7B5A00

Fields

l: f64

The luminance component. Exactly the same as CIELAB, CIELUV, and CIELCH. Varies between 0 and 100 by definition.

c: f64

The chroma component: essentially, how colorful the color is compared to white. (This is contrasted with saturation, which is how colorful a color is when compared to an equivalently bright grayscale color: a dark, deep red may have high saturation and low chroma.) This varies between 0 and about 141 for most visible colors, and is the radius in cylindrical coordinates.

h: f64

The hue component: essentially, what wavelengths of light have the highest reflectance. This is the angle from the vertical axis in cylindrical coordinates. 0 degrees corresponds to red, 90 to yellow, 180 to green, and 270 to blue. (These are called unique hues.) It ranges from 0 to 360, and any value outside that range will be interpreted as its value if one added or subtracted multiples of 360 to bring the value inside that range.

Trait Implementations

impl Clone for CIELCHuvColor

fn clone(&self) -> CIELCHuvColor

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Color for CIELCHuvColor

fn from_xyz(xyz: XYZColor) -> CIELCHuvColor

Converts from XYZ to CIELCHuv through CIELUV.

fn to_xyz(&self, illuminant: Illuminant) -> XYZColor

Gets the XYZ color that corresponds to this one, through CIELUV.

fn convert<T: Color>(&self) -> T

Converts generic colors from one representation to another. This is done by going back and forth from the CIE 1931 XYZ space, using the illuminant D50 (although this should not affect the results). Just like collect() and other methods in the standard library, the use of type inference will usually allow for clean syntax, but occasionally the turbofish is necessary.

fn hue(&self) -> f64

Gets the generally most accurate version of hue for a given color: the hue coordinate in CIELCH. There are generally considered four “unique hues” that humans perceive as not decomposable into other hues (when mixing additively): these are red, yellow, green, and blue. These unique hues have values of 0, 90, 180, and 270 degrees respectively, with other colors interpolated between them. This returned value will never be outside the range 0 to 360. For more information, you can start at the Wikpedia page.

fn set_hue(&mut self, new_hue: f64)

Sets a perceptually-accurate version hue of a color, even if the space itself does not have a conception of hue. This uses the CIELCH version of hue. To use another one, simply convert and set it manually. If the given hue is not between 0 and 360, it is shifted in that range by adding multiples of 360.

fn lightness(&self) -> f64

Gets a perceptually-accurate version of lightness as a value from 0 to 100, where 0 is black and 100 is pure white. The exact value used is CIELAB’s definition of luminance, which is generally considered a very good standard. Note that this is nonlinear with respect to the physical amount of light emitted: a material with 18% reflectance has a lightness value of 50, not 18.

fn set_lightness(&mut self, new_lightness: f64)

Sets a perceptually-accurate version of lightness, which ranges between 0 and 100 for visible colors. Any values outside of this range will be clamped within it.

fn chroma(&self) -> f64

Gets a perceptually-accurate version of chroma, defined as colorfulness relative to a similarly illuminated white. This has no explicit upper bound, but is always positive and generally between 0 and 180 for visible colors. This is done using the CIELCH model.

fn set_chroma(&mut self, new_chroma: f64)

Sets a perceptually-accurate version of chroma, defined as colorfulness relative to a similarly illuminated white. Uses CIELCH’s defintion of chroma for implementation. Any value below 0 will be clamped up to 0, but because the upper bound depends on the hue and lightness no clamping will be done. This means that this method has a higher chance than normal of producing imaginary colors and any output from this method should be checked.

fn saturation(&self) -> f64

Gets a perceptually-accurate version of saturation, defined as chroma relative to lightness. Generally ranges from 0 to around 10, although exact bounds are tricky. from This means that e.g., a very dark purple could be very highly saturated even if it does not seem so relative to lighter colors. This is computed using the CIELCH model and computing chroma divided by lightness: if the lightness is 0, the saturation is also said to be 0. There is no official formula except ones that require more information than this model of colors has, but the CIELCH formula is fairly standard.

fn set_saturation(&mut self, new_sat: f64)

Sets a perceptually-accurate version of saturation, defined as chroma relative to lightness. Does this without modifying lightness or hue. Any negative value will be clamped to 0, but because the maximum saturation is not well-defined any positive value will be used as is: this means that this method is more likely than others to produce imaginary colors. Uses the CIELCH color space. Generally, saturation ranges from 0 to about 1, but it can go higher.

fn grayscale(&self) -> Selfwhere Self: Sized,

Returns a new Color of the same type as before, but with chromaticity removed: effectively, a color created solely using a mix of black and white that has the same lightness as before. This uses the CIELAB luminance definition, which is considered a good standard and is perceptually accurate for the most part.

fn distance<T: Color>(&self, other: &T) -> f64

Returns a metric of the distance between the given color and another that attempts to accurately reflect human perception. This is done by using the CIEDE2000 difference formula, the current international and industry standard. The result, being a distance, will never be negative: it has no defined upper bound, although anything larger than 100 would be very extreme. A distance of 1.0 is conservatively the smallest possible noticeable difference: anything that is below 1.0 is almost guaranteed to be indistinguishable to most people.

fn visually_indistinguishable<T: Color>(&self, other: &T) -> bool

Using the metric that two colors with a CIEDE2000 distance of less than 1 are indistinguishable, determines whether two colors are visually distinguishable from each other. For more, check out this guide.

impl Debug for CIELCHuvColor

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CIELCHuvColor

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<CIELCHuvColor> for Coord

fn from(val: CIELCHuvColor) -> Self

Converts to this type from the input type.

impl From<Coord> for CIELCHuvColor

fn from(c: Coord) -> CIELCHuvColor

Converts to this type from the input type.

impl Serialize for CIELCHuvColor

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

Serialize this value into the given Serde serializer.

impl Copy for CIELCHuvColor