Struct prisma::Hsi

#[repr(C)]pub struct Hsi<T, A = Deg<T>> { /* fields omitted */ }

The HSI device-dependent polar color space

HSI is defined by a hue (base color), saturation (colorfulness) and intensity (brightness). While HSI has a construction very similar to HSV and HSL, it is a space with very different properties. It shares a strong similarity to HSL except that it uses $I = \frac{R + G + B}{3}$ instead of $L = \frac{max(R,G,B) + min(R,G,B)}{2}$ and is also a bi-cone space. However, HSI is not distorted to fit a cylinder as the other HS* spaces are, meaning that there are no degeneracies but also that not all $H,S,I \in [0,1]$ are valid.

HSI is often used in imaging processing for this lack of distortion, but it is notably less convenient for a human to reason through.

An extension to HSI titled eHSI and implemented as eHsi was developed to map HSI into a cylinder as well as fix a few deficiencies in the original HSI model.

Implementations

impl<T, A> Hsi<T, A> where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar + Angle<Scalar = T>, 

pub fn new(hue: A, saturation: T, intensity: T) -> Self

Construct an Hsi instance from hue, saturation and intensity

pub fn color_cast<TOut, AOut>(&self) -> Hsi<TOut, AOut> where
    T: ChannelFormatCast<TOut>,
    A: ChannelFormatCast<AOut>,
    AOut: AngularChannelScalar,
    TOut: PosNormalChannelScalar, 

Convert the internal channel scalar format

pub fn hue(&self) -> A

Returns the scalar hue

pub fn saturation(&self) -> T

Returns the scalar saturation

pub fn intensity(&self) -> T

Returns the scalar intensity

pub fn hue_mut(&mut self) -> &mut A

Returns a mutable reference to the hue scalar

pub fn saturation_mut(&mut self) -> &mut T

Returns a mutable reference to the saturation scalar

pub fn intensity_mut(&mut self) -> &mut T

Returns a mutable reference to the intensity scalar

pub fn set_hue(&mut self, val: A)

Set the hue channel value

pub fn set_saturation(&mut self, val: T)

Set the saturation channel value

pub fn set_intensity(&mut self, val: T)

Set the intensity channel value

pub fn is_same_as_ehsi(&self) -> bool

Returns whether the Hsi instance would be equivalent in eHsi

impl<T, A> Hsi<T, A> where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar + Angle<Scalar = T> + FromAngle<Rad<T>> + Display, 

pub fn to_rgb(&self, out_of_gamut_mode: HsiOutOfGamutMode) -> Rgb<T>

Convert an Hsi value to an Rgbvalue with out_of_gamut_mode specifying how to handle out-of-gamut output

Trait Implementations

impl<T, A> AbsDiffEq<Hsi<T, A>> for Hsi<T, A> where
    T: PosNormalChannelScalar + AbsDiffEq<Epsilon = A::Epsilon>,
    A: AngularChannelScalar + AbsDiffEq,
    A::Epsilon: Clone + Float, 

type Epsilon = T::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> Self::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of ApproxEq::abs_diff_eq.

impl<T, A> Bounded for Hsi<T, A> where
    T: PosNormalChannelScalar,
    A: AngularChannelScalar, 

fn normalize(self) -> Self

Return a value clipped inside the normalized range

fn is_normalized(&self) -> bool

Return true if the value is normalized

impl<T: Clone, A: Clone> Clone for Hsi<T, A>

fn clone(&self) -> Hsi<T, A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, A> Color for Hsi<T, A> where
    T: PosNormalChannelScalar,
    A: AngularChannelScalar, 

type Tag = HsiTag

The unique tag unit struct identifying the color type

type ChannelsTuple = (A, T, T)

A tuple of types for each channel in the color

fn num_channels() -> u32

Return how many channels the color has

fn to_tuple(self) -> Self::ChannelsTuple

Convert a color into a tuple of channels

impl<T: Copy, A: Copy> Copy for Hsi<T, A>

impl<T: Debug, A: Debug> Debug for Hsi<T, A>

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

Formats the value using the given formatter.

impl<T, A> Default for Hsi<T, A> where
    T: PosNormalChannelScalar + Zero,
    A: AngularChannelScalar + Zero, 

fn default() -> Self

Returns the "default value" for a type.

impl<T, A> Display for Hsi<T, A> where
    T: PosNormalChannelScalar + Display,
    A: AngularChannelScalar + Display, 

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

Formats the value using the given formatter.

impl<T, A> EncodableColor for Hsi<T, A> where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar + Angle<Scalar = T>, 

fn encoded_as<E>(self, encoding: E) -> EncodedColor<Self, E> where
    E: ColorEncoding, 

Specify what encoding the color has. This does not actually encode anything

fn linear(self) -> EncodedColor<Self, LinearEncoding>

Specify that the color is linear

fn srgb_encoded(self) -> EncodedColor<Self, SrgbEncoding>

Specify that the color is sRGB encoded

fn gamma_encoded<T: Float>(
    self,
    gamma: T
) -> EncodedColor<Self, GammaEncoding<T>>

Specify that the color is gamma encoded with a given gamma

impl<T, A> From<Rgb<T>> for Hsi<T, A> where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar + Angle<Scalar = T> + FromAngle<Rad<T>>, 

fn from(from: Rgb<T>) -> Self

Performs the conversion.

impl<T, A> FromColor<Rgb<T>> for Hsi<T, A> where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar + Angle<Scalar = T> + FromAngle<Rad<T>>, 

fn from_color(from: &Rgb<T>) -> Self

Construct Self from from

impl<T, A> FromHsi<Hsi<T, A>> for Rgb<T> where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar + Angle<Scalar = T> + IntoAngle<Rad<T>, OutputScalar = T>, 

fn from_hsi(value: &Hsi<T, A>, out_of_gamut_mode: HsiOutOfGamutMode) -> Rgb<T>

Construct Self from from, describing what to do if the color is out of gamut for Self

impl<T, A> FromTuple for Hsi<T, A> where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar + Angle<Scalar = T>, 

fn from_tuple(values: Self::ChannelsTuple) -> Self

Construct Self from a tuple of channel values

impl<T: Hash, A: Hash> Hash for Hsi<T, A>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<T, A> Invert for Hsi<T, A> where
    T: PosNormalChannelScalar,
    A: AngularChannelScalar, 

fn invert(self) -> Self

Invert Self

impl<T, A> Lerp for Hsi<T, A> where
    T: PosNormalChannelScalar + Lerp,
    A: AngularChannelScalar + Lerp, 

type Position = A::Position

The type of the pos argument

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

Interpolate between self and right

impl<T: PartialEq, A: PartialEq> PartialEq<Hsi<T, A>> for Hsi<T, A>

fn eq(&self, other: &Hsi<T, A>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Hsi<T, A>) -> bool

This method tests for !=.

impl<T: PartialOrd, A: PartialOrd> PartialOrd<Hsi<T, A>> for Hsi<T, A>

fn partial_cmp(&self, other: &Hsi<T, A>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Hsi<T, A>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Hsi<T, A>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Hsi<T, A>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Hsi<T, A>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, A> PolarColor for Hsi<T, A> where
    T: PosNormalChannelScalar,
    A: AngularChannelScalar, 

type Angular = A

The angular channel's scalar type

type Cartesian = T

The remaining channels' scalar types

impl<T, A> RelativeEq<Hsi<T, A>> for Hsi<T, A> where
    T: PosNormalChannelScalar + RelativeEq<Epsilon = A::Epsilon>,
    A: AngularChannelScalar + RelativeEq,
    A::Epsilon: Clone + Float, 

fn default_max_relative() -> Self::Epsilon

The default relative tolerance for testing values that are far-apart.

fn relative_eq(
    &self,
    other: &Self,
    epsilon: Self::Epsilon,
    max_relative: Self::Epsilon
) -> bool

A test for equality that uses a relative comparison if the values are far apart.

fn relative_ne(
    &self,
    other: &Rhs,
    epsilon: Self::Epsilon,
    max_relative: Self::Epsilon
) -> bool

The inverse of ApproxEq::relative_eq.

impl<T, A> StructuralPartialEq for Hsi<T, A>

impl<T, A> UlpsEq<Hsi<T, A>> for Hsi<T, A> where
    T: PosNormalChannelScalar + UlpsEq<Epsilon = A::Epsilon>,
    A: AngularChannelScalar + UlpsEq,
    A::Epsilon: Clone + Float, 

fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that are far-apart.

fn ulps_eq(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.

fn ulps_ne(&self, other: &Rhs, epsilon: Self::Epsilon, max_ulps: u32) -> bool

The inverse of ApproxEq::ulps_eq.