Struct scarlet::colors::hsvcolor::HSVColor

pub struct HSVColor {
    pub h: f64,
    pub s: f64,
    pub v: f64,
}

An HSV color, defining parameters for hue, saturation, and value from the RGB space. This is sHSV to be exact, but the derivation from the sRGB space is assumed as it matches the vast majority of colors called RGB.

Example

As with HSL, changing a red to a yellow results in a lightness increase as well.

let red = HSVColor{h: 0., s: 0.5, v: 0.8};
let yellow = HSVColor{h: 50., s: 0.5, v: 0.8};
println!("{} {}", red.convert::<RGBColor>().to_string(), yellow.convert::<RGBColor>().to_string());
// prints #CC6666 #CCBB66
// note how the second one is strictly more light

Fields

h: f64

The hue, described as an angle that ranges between 0 and 360 in degrees. While values outside of this range may not break, they shouldn't be treated as valid.

s: f64

The saturation, defined as the radius of the HSV cylinder and the distance between the color and the equivalent-value grayscale. Ranges between 0 and 1.

v: f64

The value, defined as the largest RGB primary value of a color. This corresponds to something close to color intensity, not really luminance: dark purple and white are the same value, for example.

Trait Implementations

impl Bound for HSVColor

fn bounds() -> [(f64, f64); 3]

Returns an array [(min1, max1), (min2, max2), (min3, max3)] that represents the bounds on each component of the color space, in the order that they appear in the Coord representation. If some parts of the bounds don't exist, using infinity or negative infinity works.

fn clamp_coord(point: Coord) -> Coord

Given a Coord, returns a Coord such that each component has been clamped to the correct bounds. See trait documentation for example usage.

fn clamp<T: ColorPoint>(color: T) -> T

Given a Color that can be embedded in 3D space, returns a new version of that color that is in the bounds of this color space, even if the coordinate systems of the two spaces differ. If the color is already in the gamut, it simply returns a copy. See trait documentation for example usage.

impl Clone for HSVColor

fn clone(&self) -> HSVColor

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Color for HSVColor

fn from_xyz(xyz: XYZColor) -> HSVColor

Converts to HSV by going through sRGB.

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

Converts from HSV back to XYZ. Any illuminant other than D65 is computed using chromatic adaptation.

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. # Example This example shows that RGB primaries are not exact standins for the hue they're named for, and using Scarlet can improve color accuracy.

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. # Examples HSL and HSV are often used to get luminance. We'll see why this can be horrifically inaccurate.

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. # Example As we saw in the lightness method, purple and yellow tend to trip up HSV and HSL: the color system doesn't account for how much brighter the color yellow is compared to the color purple. What would equiluminant purple and yellow look like? We can find out.

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. # Example Chroma differs from saturation in that it doesn't account for lightness as much as saturation: there are just fewer colors at really low light levels, and so most colors appear less colorful. This can either be the desired measure of this effect, or it can be more suitable to use saturation. A comparison:

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. # Example We can use the purple example from above, and see what an equivalent chroma to the dark purple would look like at a high lightness.

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. # Example

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. # Example

fn grayscale(&self) -> Self where
    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. # Example

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 Copy for HSVColor

impl Debug for HSVColor

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for HSVColor

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

Deserialize this value from the given Serde deserializer.

impl From<Coord> for HSVColor

fn from(c: Coord) -> HSVColor

Performs the conversion.

impl FromStr for HSVColor

type Err = CSSParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<HSVColor, CSSParseError>

Parses a string s to return a value of this type.

impl Into<Coord> for HSVColor

fn into(self) -> Coord

Performs the conversion.

impl Serialize for HSVColor

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

Serialize this value into the given Serde serializer.