[−][src]Struct valora::prelude::Hsv
Linear HSV color space.
HSV is a cylindrical version of RGB and it's very
similar to HSL. The difference is that the value
component in HSV determines the brightness of the color, and not the
lightness. The difference is that, for example, red (100% R, 0% G, 0% B)
and white (100% R, 100% G, 100% B) has the same brightness (or value), but
not the same lightness.
Fields
hue: RgbHue<T>
The hue of the color, in degrees. Decides if it's red, blue, purple, etc.
saturation: T
The colorfulness of the color. 0.0 gives gray scale colors and 1.0 will give absolutely clear colors.
value: T
Decides how bright the color will look. 0.0 will be black, and 1.0 will
give a bright an clear color that goes towards white when saturation
goes towards 0.0.
space: PhantomData<S>
The white point and RGB primaries this color is adapted to. The default is the sRGB standard.
Methods
impl<T> Hsv<Srgb, T> where
T: Component + Float,
[src]
T: Component + Float,
pub fn new<H>(hue: H, saturation: T, value: T) -> Hsv<Srgb, T> where
H: Into<RgbHue<T>>,
[src]
H: Into<RgbHue<T>>,
HSV for linear sRGB.
impl<S, T> Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
[src]
S: RgbSpace,
T: Component + Float,
pub fn with_wp<H>(hue: H, saturation: T, value: T) -> Hsv<S, T> where
H: Into<RgbHue<T>>,
[src]
H: Into<RgbHue<T>>,
Linear HSV.
pub fn into_components(self) -> (RgbHue<T>, T, T)
[src]
Convert to a (hue, saturation, value)
tuple.
pub fn from_components<H>((H, T, T)) -> Hsv<S, T> where
H: Into<RgbHue<T>>,
[src]
H: Into<RgbHue<T>>,
Convert from a (hue, saturation, value)
tuple.
Trait Implementations
impl<S, T> AbsDiffEq<Hsv<S, T>> for Hsv<S, T> where
S: RgbSpace + PartialEq<S>,
T: Component + Float + AbsDiffEq<T>,
<T as AbsDiffEq<T>>::Epsilon: Copy,
<T as AbsDiffEq<T>>::Epsilon: Float,
[src]
S: RgbSpace + PartialEq<S>,
T: Component + Float + AbsDiffEq<T>,
<T as AbsDiffEq<T>>::Epsilon: Copy,
<T as AbsDiffEq<T>>::Epsilon: Float,
type Epsilon = <T as AbsDiffEq<T>>::Epsilon
Used for specifying relative comparisons.
fn default_epsilon() -> <Hsv<S, T> as AbsDiffEq<Hsv<S, T>>>::Epsilon
[src]
fn abs_diff_eq(
&self,
other: &Hsv<S, T>,
epsilon: <T as AbsDiffEq<T>>::Epsilon
) -> bool
[src]
&self,
other: &Hsv<S, T>,
epsilon: <T as AbsDiffEq<T>>::Epsilon
) -> bool
fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool
impl<S, T> Add<Hsv<S, T>> for Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
[src]
S: RgbSpace,
T: Component + Float,
type Output = Hsv<S, T>
The resulting type after applying the +
operator.
fn add(self, other: Hsv<S, T>) -> <Hsv<S, T> as Add<Hsv<S, T>>>::Output
[src]
impl<S, T> Add<T> for Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
[src]
S: RgbSpace,
T: Component + Float,
type Output = Hsv<S, T>
The resulting type after applying the +
operator.
fn add(self, c: T) -> <Hsv<S, T> as Add<T>>::Output
[src]
impl<S, T> AddAssign<Hsv<S, T>> for Hsv<S, T> where
S: RgbSpace,
T: Component + Float + AddAssign<T>,
[src]
S: RgbSpace,
T: Component + Float + AddAssign<T>,
fn add_assign(&mut self, other: Hsv<S, T>)
[src]
impl<S, T> AddAssign<T> for Hsv<S, T> where
S: RgbSpace,
T: Component + Float + AddAssign<T>,
[src]
S: RgbSpace,
T: Component + Float + AddAssign<T>,
fn add_assign(&mut self, c: T)
[src]
impl<S, T, P> AsMut<P> for Hsv<S, T> where
P: RawPixel<T> + ?Sized,
S: RgbSpace,
T: Component + Float,
[src]
P: RawPixel<T> + ?Sized,
S: RgbSpace,
T: Component + Float,
impl<S, T, P> AsRef<P> for Hsv<S, T> where
P: RawPixel<T> + ?Sized,
S: RgbSpace,
T: Component + Float,
[src]
P: RawPixel<T> + ?Sized,
S: RgbSpace,
T: Component + Float,
impl<S, T> Clone for Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
[src]
S: RgbSpace,
T: Component + Float,
impl<S, T> Copy for Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
[src]
S: RgbSpace,
T: Component + Float,
impl<S, T> Debug for Hsv<S, T> where
S: Debug + RgbSpace,
T: Debug + Component + Float,
[src]
S: Debug + RgbSpace,
T: Debug + Component + Float,
impl<S, T> Default for Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
[src]
S: RgbSpace,
T: Component + Float,
impl<S, T, H> From<(H, T, T)> for Hsv<S, T> where
H: Into<RgbHue<T>>,
S: RgbSpace,
T: Component + Float,
[src]
H: Into<RgbHue<T>>,
S: RgbSpace,
T: Component + Float,
impl<S, T> From<Alpha<Hsl<S, T>, T>> for Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
[src]
S: RgbSpace,
T: Component + Float,
impl<S, T> From<Alpha<Hsv<S, T>, T>> for Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
[src]
S: RgbSpace,
T: Component + Float,
impl<S, T> From<Alpha<Hwb<S, T>, T>> for Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
[src]
S: RgbSpace,
T: Component + Float,
impl<S, T> From<Alpha<Lab<<S as RgbSpace>::WhitePoint, T>, T>> for Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
[src]
S: RgbSpace,
T: Component + Float,
impl<S, T> From<Alpha<Lch<<S as RgbSpace>::WhitePoint, T>, T>> for Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
[src]
S: RgbSpace,
T: Component + Float,
impl<S, T, _S> From<Alpha<Luma<_S, T>, T>> for Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
_S: LumaStandard<WhitePoint = <S as RgbSpace>::WhitePoint>,
[src]
S: RgbSpace,
T: Component + Float,
_S: LumaStandard<WhitePoint = <S as RgbSpace>::WhitePoint>,
impl<S, T, _S> From<Alpha<Rgb<_S, T>, T>> for Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
_S: RgbStandard<Space = S>,
[src]
S: RgbSpace,
T: Component + Float,
_S: RgbStandard<Space = S>,
impl<S, T> From<Alpha<Xyz<<S as RgbSpace>::WhitePoint, T>, T>> for Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
[src]
S: RgbSpace,
T: Component + Float,
impl<S, T> From<Alpha<Yxy<<S as RgbSpace>::WhitePoint, T>, T>> for Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
[src]
S: RgbSpace,
T: Component + Float,
impl<S, Sp, T> From<Hsl<Sp, T>> for Hsv<S, T> where
S: RgbSpace,
Sp: RgbSpace<WhitePoint = <S as RgbSpace>::WhitePoint>,
T: Component + Float,
[src]
S: RgbSpace,
Sp: RgbSpace<WhitePoint = <S as RgbSpace>::WhitePoint>,
T: Component + Float,
impl<S, T> From<Hsv<<S as RgbStandard>::Space, T>> for Alpha<Rgb<S, T>, T> where
S: RgbStandard,
T: Component + Float,
[src]
S: RgbStandard,
T: Component + Float,
impl<S, T> From<Hsv<S, T>> for Alpha<Hsl<S, T>, T> where
S: RgbSpace,
T: Component + Float,
[src]
S: RgbSpace,
T: Component + Float,
impl<S, T> From<Hsv<S, T>> for Alpha<Hwb<S, T>, T> where
S: RgbSpace,
T: Component + Float,
[src]
S: RgbSpace,
T: Component + Float,
impl<S, T, Sp> From<Hsv<Sp, T>> for Hwb<S, T> where
S: RgbSpace,
Sp: RgbSpace<WhitePoint = <S as RgbSpace>::WhitePoint>,
T: Component + Float,
[src]
S: RgbSpace,
Sp: RgbSpace<WhitePoint = <S as RgbSpace>::WhitePoint>,
T: Component + Float,
impl<S, Sp, T> From<Hsv<Sp, T>> for Hsl<S, T> where
S: RgbSpace,
Sp: RgbSpace<WhitePoint = <S as RgbSpace>::WhitePoint>,
T: Component + Float,
[src]
S: RgbSpace,
Sp: RgbSpace<WhitePoint = <S as RgbSpace>::WhitePoint>,
T: Component + Float,
impl<S, T, Sp, Wp> From<Hsv<Sp, T>> for Rgb<S, T> where
S: RgbStandard,
Sp: RgbSpace<WhitePoint = Wp>,
T: Component + Float,
Wp: WhitePoint,
<S as RgbStandard>::Space: RgbSpace,
<<S as RgbStandard>::Space as RgbSpace>::WhitePoint == Wp,
[src]
S: RgbStandard,
Sp: RgbSpace<WhitePoint = Wp>,
T: Component + Float,
Wp: WhitePoint,
<S as RgbStandard>::Space: RgbSpace,
<<S as RgbStandard>::Space as RgbSpace>::WhitePoint == Wp,
impl<Wp, T, _S> From<Hsv<_S, T>> for Alpha<Lab<Wp, T>, T> where
T: Component + Float,
Wp: WhitePoint,
_S: RgbSpace<WhitePoint = Wp>,
[src]
T: Component + Float,
Wp: WhitePoint,
_S: RgbSpace<WhitePoint = Wp>,
impl<Wp, T, _S> From<Hsv<_S, T>> for Lab<Wp, T> where
T: Component + Float,
Wp: WhitePoint,
_S: RgbSpace<WhitePoint = Wp>,
[src]
T: Component + Float,
Wp: WhitePoint,
_S: RgbSpace<WhitePoint = Wp>,
impl<Wp, T, _S> From<Hsv<_S, T>> for Yxy<Wp, T> where
T: Component + Float,
Wp: WhitePoint,
_S: RgbSpace<WhitePoint = Wp>,
[src]
T: Component + Float,
Wp: WhitePoint,
_S: RgbSpace<WhitePoint = Wp>,
impl<Wp, T, _S> From<Hsv<_S, T>> for Alpha<Xyz<Wp, T>, T> where
T: Component + Float,
Wp: WhitePoint,
_S: RgbSpace<WhitePoint = Wp>,
[src]
T: Component + Float,
Wp: WhitePoint,
_S: RgbSpace<WhitePoint = Wp>,
impl<Wp, T, _S> From<Hsv<_S, T>> for Xyz<Wp, T> where
T: Component + Float,
Wp: WhitePoint,
_S: RgbSpace<WhitePoint = Wp>,
[src]
T: Component + Float,
Wp: WhitePoint,
_S: RgbSpace<WhitePoint = Wp>,
impl<Wp, T, _S> From<Hsv<_S, T>> for Alpha<Lch<Wp, T>, T> where
T: Component + Float,
Wp: WhitePoint,
_S: RgbSpace<WhitePoint = Wp>,
[src]
T: Component + Float,
Wp: WhitePoint,
_S: RgbSpace<WhitePoint = Wp>,
impl<Wp, T, _S> From<Hsv<_S, T>> for Alpha<Yxy<Wp, T>, T> where
T: Component + Float,
Wp: WhitePoint,
_S: RgbSpace<WhitePoint = Wp>,
[src]
T: Component + Float,
Wp: WhitePoint,
_S: RgbSpace<WhitePoint = Wp>,
impl<Wp, T, _S> From<Hsv<_S, T>> for Lch<Wp, T> where
T: Component + Float,
Wp: WhitePoint,
_S: RgbSpace<WhitePoint = Wp>,
[src]
T: Component + Float,
Wp: WhitePoint,
_S: RgbSpace<WhitePoint = Wp>,
impl<S, T, _S> From<Hsv<_S, T>> for Luma<S, T> where
S: LumaStandard,
T: Component + Float,
_S: RgbSpace<WhitePoint = <S as LumaStandard>::WhitePoint>,
[src]
S: LumaStandard,
T: Component + Float,
_S: RgbSpace<WhitePoint = <S as LumaStandard>::WhitePoint>,
impl<S, T, _S> From<Hsv<_S, T>> for Alpha<Luma<S, T>, T> where
S: LumaStandard,
T: Component + Float,
_S: RgbSpace<WhitePoint = <S as LumaStandard>::WhitePoint>,
[src]
S: LumaStandard,
T: Component + Float,
_S: RgbSpace<WhitePoint = <S as LumaStandard>::WhitePoint>,
impl<S, Sp, T> From<Hwb<Sp, T>> for Hsv<S, T> where
S: RgbSpace,
Sp: RgbSpace<WhitePoint = <S as RgbSpace>::WhitePoint>,
T: Component + Float,
[src]
S: RgbSpace,
Sp: RgbSpace<WhitePoint = <S as RgbSpace>::WhitePoint>,
T: Component + Float,
impl<S, T> From<Lab<<S as RgbSpace>::WhitePoint, T>> for Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
[src]
S: RgbSpace,
T: Component + Float,
impl<S, T> From<Lch<<S as RgbSpace>::WhitePoint, T>> for Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
[src]
S: RgbSpace,
T: Component + Float,
impl<S, T, _S> From<Luma<_S, T>> for Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
_S: LumaStandard<WhitePoint = <S as RgbSpace>::WhitePoint>,
[src]
S: RgbSpace,
T: Component + Float,
_S: LumaStandard<WhitePoint = <S as RgbSpace>::WhitePoint>,
impl<S, T, _S> From<Rgb<_S, T>> for Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
_S: RgbStandard<Space = S>,
[src]
S: RgbSpace,
T: Component + Float,
_S: RgbStandard<Space = S>,
impl<S, T> From<Xyz<<S as RgbSpace>::WhitePoint, T>> for Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
[src]
S: RgbSpace,
T: Component + Float,
impl<S, T> From<Yxy<<S as RgbSpace>::WhitePoint, T>> for Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
[src]
S: RgbSpace,
T: Component + Float,
impl<S, T> FromColor<<S as RgbSpace>::WhitePoint, T> for Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
[src]
S: RgbSpace,
T: Component + Float,
fn from_xyz(color: Xyz<<S as RgbSpace>::WhitePoint, T>) -> Hsv<S, T>
[src]
fn from_rgb<_S>(color: Rgb<Linear<_S>, T>) -> Hsv<S, T> where
_S: RgbSpace<WhitePoint = <S as RgbSpace>::WhitePoint>,
[src]
_S: RgbSpace<WhitePoint = <S as RgbSpace>::WhitePoint>,
fn from_hsl<_S>(color: Hsl<_S, T>) -> Hsv<S, T> where
_S: RgbSpace<WhitePoint = <S as RgbSpace>::WhitePoint>,
[src]
_S: RgbSpace<WhitePoint = <S as RgbSpace>::WhitePoint>,
fn from_hwb<_S>(color: Hwb<_S, T>) -> Hsv<S, T> where
_S: RgbSpace<WhitePoint = <S as RgbSpace>::WhitePoint>,
[src]
_S: RgbSpace<WhitePoint = <S as RgbSpace>::WhitePoint>,
fn from_hsv<_S>(color: Hsv<_S, T>) -> Hsv<S, T> where
_S: RgbSpace<WhitePoint = <S as RgbSpace>::WhitePoint>,
[src]
_S: RgbSpace<WhitePoint = <S as RgbSpace>::WhitePoint>,
fn from_yxy(inp: Yxy<Wp, T>) -> Self
[src]
fn from_lab(inp: Lab<Wp, T>) -> Self
[src]
fn from_lch(inp: Lch<Wp, T>) -> Self
[src]
fn from_luma(inp: Luma<Linear<Wp>, T>) -> Self
[src]
impl<S, T> GetHue for Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
[src]
S: RgbSpace,
T: Component + Float,
type Hue = RgbHue<T>
The kind of hue unit this color space uses. Read more
fn get_hue(&self) -> Option<RgbHue<T>>
[src]
impl<S, T> Hue for Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
[src]
S: RgbSpace,
T: Component + Float,
fn with_hue<H>(&self, hue: H) -> Hsv<S, T> where
H: Into<<Hsv<S, T> as GetHue>::Hue>,
[src]
H: Into<<Hsv<S, T> as GetHue>::Hue>,
fn shift_hue<H>(&self, amount: H) -> Hsv<S, T> where
H: Into<<Hsv<S, T> as GetHue>::Hue>,
[src]
H: Into<<Hsv<S, T> as GetHue>::Hue>,
impl<S, T> Into<(RgbHue<T>, T, T)> for Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
[src]
S: RgbSpace,
T: Component + Float,
impl<S, Wp, T> IntoColor<Wp, T> for Hsv<S, T> where
S: RgbSpace<WhitePoint = Wp>,
T: Component + Float,
Wp: WhitePoint,
[src]
S: RgbSpace<WhitePoint = Wp>,
T: Component + Float,
Wp: WhitePoint,
fn into_xyz(self) -> Xyz<Wp, T>
[src]
fn into_yxy(self) -> Yxy<Wp, T>
[src]
fn into_lab(self) -> Lab<Wp, T>
[src]
fn into_lch(self) -> Lch<Wp, T>
[src]
fn into_rgb<Sp>(self) -> Rgb<Linear<Sp>, T> where
Sp: RgbSpace<WhitePoint = Wp>,
[src]
Sp: RgbSpace<WhitePoint = Wp>,
fn into_hsl<Sp>(self) -> Hsl<Sp, T> where
Sp: RgbSpace<WhitePoint = Wp>,
[src]
Sp: RgbSpace<WhitePoint = Wp>,
fn into_hsv<Sp>(self) -> Hsv<Sp, T> where
Sp: RgbSpace<WhitePoint = Wp>,
[src]
Sp: RgbSpace<WhitePoint = Wp>,
fn into_luma(self) -> Luma<Linear<Wp>, T>
[src]
fn into_hwb<S>(self) -> Hwb<S, T> where
S: RgbSpace<WhitePoint = Wp>,
[src]
S: RgbSpace<WhitePoint = Wp>,
impl<S, T> Limited for Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
[src]
S: RgbSpace,
T: Component + Float,
impl<S, T> Mix for Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
[src]
S: RgbSpace,
T: Component + Float,
type Scalar = T
The type of the mixing factor.
fn mix(&self, other: &Hsv<S, T>, factor: T) -> Hsv<S, T>
[src]
impl<S, T> PartialEq<Hsv<S, T>> for Hsv<S, T> where
S: PartialEq<S> + RgbSpace,
T: PartialEq<T> + Component + Float,
[src]
S: PartialEq<S> + RgbSpace,
T: PartialEq<T> + Component + Float,
impl<S, T> Pixel<T> for Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
[src]
S: RgbSpace,
T: Component + Float,
const CHANNELS: usize
[src]
fn as_raw<P>(&self) -> &P where
P: RawPixel<T> + ?Sized,
[src]
P: RawPixel<T> + ?Sized,
fn as_raw_mut<P>(&mut self) -> &mut P where
P: RawPixel<T> + ?Sized,
[src]
P: RawPixel<T> + ?Sized,
fn into_raw<P>(self) -> P where
P: RawPixelSized<T>,
[src]
P: RawPixelSized<T>,
fn from_raw<P>(pixel: &P) -> &Self where
P: RawPixel<T> + ?Sized,
[src]
P: RawPixel<T> + ?Sized,
fn from_raw_mut<P>(pixel: &mut P) -> &mut Self where
P: RawPixel<T> + ?Sized,
[src]
P: RawPixel<T> + ?Sized,
fn from_raw_slice(slice: &[T]) -> &[Self]
[src]
fn from_raw_slice_mut(slice: &mut [T]) -> &mut [Self]
[src]
fn into_raw_slice(slice: &[Self]) -> &[T]
[src]
fn into_raw_slice_mut(slice: &mut [Self]) -> &mut [T]
[src]
impl<S, T> RelativeEq<Hsv<S, T>> for Hsv<S, T> where
S: RgbSpace + PartialEq<S>,
T: Component + Float + RelativeEq<T>,
<T as AbsDiffEq<T>>::Epsilon: Copy,
<T as AbsDiffEq<T>>::Epsilon: Float,
[src]
S: RgbSpace + PartialEq<S>,
T: Component + Float + RelativeEq<T>,
<T as AbsDiffEq<T>>::Epsilon: Copy,
<T as AbsDiffEq<T>>::Epsilon: Float,
fn default_max_relative() -> <Hsv<S, T> as AbsDiffEq<Hsv<S, T>>>::Epsilon
[src]
fn relative_eq(
&self,
other: &Hsv<S, T>,
epsilon: <Hsv<S, T> as AbsDiffEq<Hsv<S, T>>>::Epsilon,
max_relative: <Hsv<S, T> as AbsDiffEq<Hsv<S, T>>>::Epsilon
) -> bool
[src]
&self,
other: &Hsv<S, T>,
epsilon: <Hsv<S, T> as AbsDiffEq<Hsv<S, T>>>::Epsilon,
max_relative: <Hsv<S, T> as AbsDiffEq<Hsv<S, T>>>::Epsilon
) -> bool
fn relative_ne(
&self,
other: &Rhs,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
&self,
other: &Rhs,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
impl<S, T> Saturate for Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
[src]
S: RgbSpace,
T: Component + Float,
type Scalar = T
The type of the (de)saturation factor.
fn saturate(&self, factor: T) -> Hsv<S, T>
[src]
fn desaturate(&self, factor: Self::Scalar) -> Self
[src]
impl<S, T> Shade for Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
[src]
S: RgbSpace,
T: Component + Float,
type Scalar = T
The type of the lighten/darken amount.
fn lighten(&self, amount: T) -> Hsv<S, T>
[src]
fn darken(&self, amount: Self::Scalar) -> Self
[src]
impl<S, T> StructuralPartialEq for Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
[src]
S: RgbSpace,
T: Component + Float,
impl<S, T> Sub<Hsv<S, T>> for Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
[src]
S: RgbSpace,
T: Component + Float,
type Output = Hsv<S, T>
The resulting type after applying the -
operator.
fn sub(self, other: Hsv<S, T>) -> <Hsv<S, T> as Sub<Hsv<S, T>>>::Output
[src]
impl<S, T> Sub<T> for Hsv<S, T> where
S: RgbSpace,
T: Component + Float,
[src]
S: RgbSpace,
T: Component + Float,
type Output = Hsv<S, T>
The resulting type after applying the -
operator.
fn sub(self, c: T) -> <Hsv<S, T> as Sub<T>>::Output
[src]
impl<S, T> SubAssign<Hsv<S, T>> for Hsv<S, T> where
S: RgbSpace,
T: Component + Float + SubAssign<T>,
[src]
S: RgbSpace,
T: Component + Float + SubAssign<T>,
fn sub_assign(&mut self, other: Hsv<S, T>)
[src]
impl<S, T> SubAssign<T> for Hsv<S, T> where
S: RgbSpace,
T: Component + Float + SubAssign<T>,
[src]
S: RgbSpace,
T: Component + Float + SubAssign<T>,
fn sub_assign(&mut self, c: T)
[src]
impl<S, T> UlpsEq<Hsv<S, T>> for Hsv<S, T> where
S: RgbSpace + PartialEq<S>,
T: Component + Float + UlpsEq<T>,
<T as AbsDiffEq<T>>::Epsilon: Copy,
<T as AbsDiffEq<T>>::Epsilon: Float,
[src]
S: RgbSpace + PartialEq<S>,
T: Component + Float + UlpsEq<T>,
<T as AbsDiffEq<T>>::Epsilon: Copy,
<T as AbsDiffEq<T>>::Epsilon: Float,
Auto Trait Implementations
impl<S, T> RefUnwindSafe for Hsv<S, T> where
S: RefUnwindSafe,
T: RefUnwindSafe,
S: RefUnwindSafe,
T: RefUnwindSafe,
impl<S, T> Send for Hsv<S, T> where
S: Send,
T: Send,
S: Send,
T: Send,
impl<S, T> Sync for Hsv<S, T> where
S: Sync,
T: Sync,
S: Sync,
T: Sync,
impl<S, T> Unpin for Hsv<S, T> where
S: Unpin,
T: Unpin,
S: Unpin,
T: Unpin,
impl<S, T> UnwindSafe for Hsv<S, T> where
S: UnwindSafe,
T: UnwindSafe,
S: UnwindSafe,
T: UnwindSafe,
Blanket Implementations
impl<S, D, Swp, Dwp, T> AdaptFrom<S, Swp, Dwp, T> for D where
D: FromColor<Dwp, T>,
Dwp: WhitePoint,
S: IntoColor<Swp, T>,
Swp: WhitePoint,
T: Component + Float,
[src]
D: FromColor<Dwp, T>,
Dwp: WhitePoint,
S: IntoColor<Swp, T>,
Swp: WhitePoint,
T: Component + Float,
fn adapt_from_using<M>(color: S, method: M) -> D where
M: TransformMatrix<Swp, Dwp, T>,
[src]
M: TransformMatrix<Swp, Dwp, T>,
fn adapt_from(color: S) -> Self
[src]
impl<S, D, Swp, Dwp, T> AdaptInto<D, Swp, Dwp, T> for S where
D: AdaptFrom<S, Swp, Dwp, T>,
Dwp: WhitePoint,
Swp: WhitePoint,
T: Component + Float,
[src]
D: AdaptFrom<S, Swp, Dwp, T>,
Dwp: WhitePoint,
Swp: WhitePoint,
T: Component + Float,
fn adapt_into_using<M>(self, method: M) -> D where
M: TransformMatrix<Swp, Dwp, T>,
[src]
M: TransformMatrix<Swp, Dwp, T>,
fn adapt_into(self) -> D
[src]
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T, Right> ClosedAdd<Right> for T where
T: Add<Right, Output = T> + AddAssign<Right>,
T: Add<Right, Output = T> + AddAssign<Right>,
impl<T, Right> ClosedSub<Right> for T where
T: Sub<Right, Output = T> + SubAssign<Right>,
T: Sub<Right, Output = T> + SubAssign<Right>,
impl<T> Content for T where
T: Copy,
[src]
T: Copy,
type Owned = T
A type that holds a sized version of the content.
fn read<F, E>(size: usize, f: F) -> Result<T, E> where
F: FnOnce(&mut T) -> Result<(), E>,
[src]
F: FnOnce(&mut T) -> Result<(), E>,
fn get_elements_size() -> usize
[src]
fn to_void_ptr(&self) -> *const ()
[src]
fn ref_from_ptr(ptr: *mut (), size: usize) -> Option<*mut T>
[src]
fn is_size_suitable(size: usize) -> bool
[src]
impl<T, U> ConvertFrom<T> for U where
U: From<T> + Limited,
[src]
U: From<T> + Limited,
fn convert_from(t: T) -> U
[src]
fn try_convert_from(t: T) -> Result<U, OutOfBounds<U>>
[src]
fn convert_unclamped_from(val: T) -> Self
[src]
impl<T, U> ConvertInto<U> for T where
U: ConvertFrom<T>,
[src]
U: ConvertFrom<T>,
fn convert_into(self) -> U
[src]
fn convert_unclamped_into(self) -> U
[src]
fn try_convert_into(self) -> Result<U, OutOfBounds<U>>
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> Same<T> for T
type Output = T
Should always be Self
impl<T> Scalar for T where
T: PartialEq<T> + Copy + Any + Debug,
[src]
T: PartialEq<T> + Copy + Any + Debug,
impl<T> SetParameter for T
fn set<T>(&mut self, value: T) -> <T as Parameter<Self>>::Result where
T: Parameter<Self>,
T: Parameter<Self>,
impl<T> SetParameter for T
fn set<T>(&mut self, value: T) -> <T as Parameter<Self>>::Result where
T: Parameter<Self>,
T: Parameter<Self>,
impl<SS, SP> SupersetOf<SS> for SP where
SS: SubsetOf<SP>,
SS: SubsetOf<SP>,
fn to_subset(&self) -> Option<SS>
fn is_in_subset(&self) -> bool
unsafe fn to_subset_unchecked(&self) -> SS
fn from_subset(element: &SS) -> SP
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,