Struct prisma::eHsi

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

The eHSI device-dependent polar color model

eHSI has the same components as Hsi: hue, saturation, intensity but has additional logic for rescaling saturation in the case of what would be out-of-gamut colors in the original HSI model. eHSI was adapted from the algorithm described in:

K. Yoshinari, Y. Hoshi and A. Taguchi, "Color image enhancement in HSI color space
without gamut problem," 2014 6th International Symposium on Communications,
Control and Signal Processing (ISCCSP), Athens, 2014, pp. 578-581.

found freely here.

eHSI is fully defined over the cylinder, and is generally visually better at adjusting intensity.

Implementations

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

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

Construct an eHsi instance from hue, saturation and intensity.

pub fn color_cast<TOut, AOut>(&self) -> eHsi<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 hue scalar

pub fn saturation(&self) -> T

Returns the saturation scalar

pub fn intensity(&self) -> T

Returns the intensity scalar

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_hsi(&self) -> bool

Returns whether the eHsi instance would be the same in Hsi

pub fn to_hsi(&self) -> Option<Hsi<T, A>>

Returns an Hsi instance that is the same as self if they would be equivalent, or None otherwise

pub fn from_hsi(hsi: &Hsi<T, A>) -> Option<eHsi<T, A>>

Construct an eHsi instance from an Hsi instance if both would be equivalent

If they would not be equivalent, returns None.

Trait Implementations

impl<T, A> AbsDiffEq<eHsi<T, A>> for eHsi<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 eHsi<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 eHsi<T, A>

fn clone(&self) -> eHsi<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 eHsi<T, A> where
    T: PosNormalChannelScalar,
    A: AngularChannelScalar, 

type Tag = EHsiTag

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 eHsi<T, A>

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

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the "default value" for a type.

impl<T, A> Display for eHsi<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 eHsi<T, A> where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar + Angle<Scalar = T> + FromAngle<Turns<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 eHsi<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 eHsi<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> FromColor<eHsi<T, A>> for Rgb<T> where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar + Angle<Scalar = T>, 

fn from_color(from: &eHsi<T, A>) -> Rgb<T>

Construct Self from from

impl<T, A> FromTuple for eHsi<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 eHsi<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 eHsi<T, A> where
    T: PosNormalChannelScalar,
    A: AngularChannelScalar, 

fn invert(self) -> Self

Invert Self

impl<T, A> Lerp for eHsi<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<eHsi<T, A>> for eHsi<T, A>

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

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

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

This method tests for !=.

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

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

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

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

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

fn le(&self, other: &eHsi<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: &eHsi<T, A>) -> bool

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

fn ge(&self, other: &eHsi<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 eHsi<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<eHsi<T, A>> for eHsi<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 eHsi<T, A>

impl<T, A> UlpsEq<eHsi<T, A>> for eHsi<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.