Struct GrayAlpha

#[repr(C)]
pub struct GrayAlpha<T, A = T>(pub T, pub A);

A pixel for grayscale value + alpha components (rgb crate v0.8)

Through a Deref hack it renames the fields from .0 and .1 to .v (value) and .a (alpha)

Tuple Fields

0: T

👎Deprecated: Please use the .v field instaed (it’s available through the magic of Deref to GrayA type)

Grayscale Component

This field has been renamed to .v

1: A

👎Deprecated: Please use the .a field instead (it’s available through the magic of Deref to GrayA type)

Alpha Component. This field has been renamed to .a.

Implementations

impl<T: Copy> GrayAlpha_v08<T>

pub fn value(self) -> T

Reads the .v field

Please use the .v field directly whenever possible. This function isn’t necessary, and exists only to ease migration between major versions of the RGB crate.

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

Exposes the .v field for writing

Please use the .v field directly whenever possible. This function isn’t necessary, and exists only to ease migration between major versions of the RGB crate.

impl<T: Copy> GrayAlpha_v08<T>

pub const fn new(value: T, alpha: T) -> Self

Creates a new GrayAlpha_v08 pixel type from its components.

Alternatively, you can use struct literal syntax to create the new pixel type:

use rgb::GrayAlpha_v08;

let pixel = GrayAlpha_v08 {0 : value, 1 : alpha};

impl<T: Clone, A> GrayAlpha<T, A>

pub fn gray(&self) -> Gray<T>

Copy Gray component out of the GrayAlpha struct

impl<T, A> GrayAlpha<T, A>

pub fn gray_mut(&mut self) -> &mut Gray<T>

Provide a mutable view of only Gray component (leaving out alpha).

impl<T: Copy, A: Clone> GrayAlpha<T, A>

pub fn with_alpha(&self, a: A) -> Self

Create a new GrayAlpha with the new alpha value, but same gray value

pub fn map_alpha<F, B>(&self, f: F) -> GrayAlpha<T, B>

where F: FnOnce(A) -> B,

Create a new GrayAlpha with a new alpha value created by the callback.

pub fn map_gray<F, U, B>(&self, f: F) -> GrayAlpha<U, B>

where F: FnOnce(T) -> U, U: Clone, B: From<A> + Clone,

Create new GrayAlpha with the same alpha value, but different Gray value

Trait Implementations

impl<T> Add<T> for GrayAlpha<T>

where T: Copy + Add<Output = T>,

px + 1

type Output = GrayAlpha_v08<T>

The resulting type after applying the + operator.

fn add(self, r: T) -> Self::Output

Performs the + operation.

impl<T: Add, A: Add> Add for GrayAlpha<T, A>

px + px

type Output = GrayAlpha_v08<<T as Add>::Output, <A as Add>::Output>

The resulting type after applying the + operator.

fn add(self, other: GrayAlpha<T, A>) -> Self::Output

Performs the + operation.

impl<T> AddAssign<T> for GrayAlpha<T>

where T: Copy + Add<Output = T>,

px + 1

fn add_assign(&mut self, r: T)

Performs the += operation.

impl<T, A> AddAssign for GrayAlpha<T, A>

where T: Add<Output = T> + Copy, A: Add<Output = A> + Copy,

px + px

fn add_assign(&mut self, other: GrayAlpha<T, A>)

Performs the += operation.

impl<T> AsMut<T> for GrayAlpha<T>

fn as_mut(&mut self) -> &mut T

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T> AsPixels<GrayAlpha_v08<T>> for [T]

fn as_pixels(&self) -> &[GrayAlpha<T>]

Use ::bytemuck::cast_slice() instead.

fn as_pixels_mut(&mut self) -> &mut [GrayAlpha<T>]

Use ::bytemuck::cast_slice_mut() instead.

impl<T> AsRef<T> for GrayAlpha<T>

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Copy, A: Copy, B> ColorComponentMap<GrayAlpha_v08<B, A>, T, B> for GrayAlpha<T, A>

fn map_colors<F>(&self, f: F) -> GrayAlpha<B, A>

where F: FnMut(T) -> B,

Convenience function for applying the same formula to every rgb/gray component, but skipping the alpha component.

fn map_c<Callback>(&self, f: Callback) -> DestPixel

where Callback: FnMut(SrcComponent) -> DestComponent,

👎Deprecated: renamed to map_colors

Alias of map_colors

impl<T: Copy, B> ComponentMap<GrayAlpha_v08<B>, T, B> for GrayAlpha<T>

fn map<F>(&self, f: F) -> GrayAlpha<B>

where F: FnMut(T) -> B,

Convenience function (equivalent of self.iter().map().collect()) for applying the same formula to every component.

impl<T> ComponentSlice<T> for GrayAlpha<T>

fn as_slice(&self) -> &[T]

The components interpreted as an array, e.g. one RGB expands to 3 elements.

fn as_mut_slice(&mut self) -> &mut [T]

The components interpreted as a mutable array, e.g. one RGB expands to 3 elements.

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

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

Formats the value using the given formatter.

impl<T: Default, A: Default> Default for GrayAlpha_v08<T, A>

fn default() -> GrayAlpha_v08<T, A>

Returns the “default value” for a type.

impl<T, A> Deref for GrayAlpha_v08<T, A>

fn deref(&self) -> &GrayA<T, A>

A trick that allows using .v and .a on the old GrayAlpha type.

type Target = GrayA<T, A>

The resulting type after dereferencing.

impl<T, A> DerefMut for GrayAlpha_v08<T, A>

fn deref_mut(&mut self) -> &mut GrayA<T, A>

A trick that allows using .v and .a on the old GrayAlpha type.

impl<T> Div<T> for GrayAlpha<T>

where T: Copy + Div<Output = T>,

px / 1

type Output = GrayAlpha_v08<T>

The resulting type after applying the / operator.

fn div(self, r: T) -> Self::Output

Performs the / operation.

impl<T> DivAssign<T> for GrayAlpha<T>

where T: Copy + Div<Output = T>,

px * 1

fn div_assign(&mut self, r: T)

Performs the /= operation.

impl<R, S> From<(R, R)> for GrayAlpha<S>

where R: Into<S>,

fn from(value: (R, R)) -> Self

Converts to this type from the input type.

impl<R, S> From<GrayAlpha_v08<R>> for (S, S)

where R: Into<S>,

fn from(value: GrayAlpha<R>) -> Self

Converts to this type from the input type.

impl<T: Clone, A> From<GrayAlpha_v08<T, A>> for Rgba<T, A>

fn from(other: GrayAlpha<T, A>) -> Self

Converts to this type from the input type.

impl<T: Copy> From<Gray_v08<T>> for GrayAlpha<T, u16>

Assumes 65535 is opaque

fn from(other: Gray<T>) -> Self

Converts to this type from the input type.

impl<T: Copy> From<Gray_v08<T>> for GrayAlpha<T, u8>

Assumes 255 is opaque

fn from(other: Gray<T>) -> Self

Converts to this type from the input type.

impl<T: Hash, A: Hash> Hash for GrayAlpha_v08<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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> Mul<T> for GrayAlpha<T>

where T: Copy + Mul<Output = T>,

px * 1

type Output = GrayAlpha_v08<T>

The resulting type after applying the * operator.

fn mul(self, r: T) -> Self::Output

Performs the * operation.

impl<T> MulAssign<T> for GrayAlpha<T>

where T: Copy + Mul<Output = T>,

px * 1

fn mul_assign(&mut self, r: T)

Performs the *= operation.

impl<T: Ord, A: Ord> Ord for GrayAlpha_v08<T, A>

fn cmp(&self, other: &GrayAlpha_v08<T, A>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

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

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

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

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

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

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

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

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

impl<T> Sub<T> for GrayAlpha<T>

where T: Copy + Sub<Output = T>,

px - 1

type Output = GrayAlpha_v08<<T as Sub>::Output>

The resulting type after applying the - operator.

fn sub(self, r: T) -> Self::Output

Performs the - operation.

impl<T: Sub, A: Sub> Sub for GrayAlpha<T, A>

px - px

type Output = GrayAlpha_v08<<T as Sub>::Output, <A as Sub>::Output>

The resulting type after applying the - operator.

fn sub(self, other: GrayAlpha<T, A>) -> Self::Output

Performs the - operation.

impl<T> SubAssign<T> for GrayAlpha<T>

where T: Copy + Sub<Output = T>,

px - 1

fn sub_assign(&mut self, r: T)

Performs the -= operation.

impl<T, A> SubAssign for GrayAlpha<T, A>

where T: Sub<Output = T> + Copy, A: Sub<Output = A> + Copy,

px - px

fn sub_assign(&mut self, other: GrayAlpha<T, A>)

Performs the -= operation.

impl<T, A> Sum for GrayAlpha<T, A>

where T: Default + Add<Output = T>, A: Default + Add<Output = A>,

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<T, A> Zeroable for GrayAlpha<T, A>

where T: Zeroable, A: Zeroable,

This is unsound. You can disable as-bytes feature, enable bytemuck, and use bytemuck::cast_slice() instead.

fn zeroed() -> Self

Calls zeroed.

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

impl<T: Eq, A: Eq> Eq for GrayAlpha_v08<T, A>

impl<T, A> Pod for GrayAlpha<T, A>

where T: Pod, A: Pod,

This is unsound. You can disable as-bytes feature, enable bytemuck, and use bytemuck::cast_slice() instead.

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