Struct PalettedRgba 

pub struct PalettedRgba<'p> {
    pub index: u8,
    /* private fields */
}

Represents a paletted pixel, holding an index to a palette of Rgba colors represented as a &'p [Rgba], where 'p is the lifetime of the palette.

Fields

index: u8

Trait Implementations

impl<'p> Clone for PalettedRgba<'p>

fn clone(&self) -> PalettedRgba<'p>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'p> Copy for PalettedRgba<'p>

impl Debug for PalettedRgba<'_>

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

Formats the value using the given formatter.

impl Default for PalettedRgba<'_>

fn default() -> Self

Returns the “default value” for a type.

impl<'p> Eq for PalettedRgba<'p>

impl From<PalettedRgba<'_>> for Rgb

fn from(pixel: PalettedRgba<'_>) -> Self

Converts to this type from the input type.

impl From<PalettedRgba<'_>> for Rgba

fn from(pixel: PalettedRgba<'_>) -> Self

Converts to this type from the input type.

impl From<PalettedRgba<'_>> for L

fn from(pixel: PalettedRgba<'_>) -> Self

Converts to this type from the input type.

impl From<PalettedRgba<'_>> for BitPixel

fn from(pixel: PalettedRgba<'_>) -> Self

Converts to this type from the input type.

impl From<PalettedRgba<'_>> for Dynamic

fn from(pixel: PalettedRgba<'_>) -> Self

Converts to this type from the input type.

impl<'p> Hash for PalettedRgba<'p>

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<'p> Not for PalettedRgba<'p>

type Output = PalettedRgba<'p>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<'p> Paletted<'p> for PalettedRgba<'p>

fn from_palette(palette: &'p [Self::Color], index: Self::Subpixel) -> Self

Creates this pixel from the given palette and index. For unpaletted pixels, use Pixel::from_arbitrary_palette instead.

fn palette(&self) -> &'p [Self::Color]

Returns the palette lookup as a slice.

fn palette_index(&self) -> u8

Returns the index in the palette this pixel is of.

fn color(&self) -> Self::Color

Resolves the color of the pixel. Because invalid palette values are supposed to be propagated prior to calling this, this will panic

unsafe fn color_unchecked(&self) -> Self::Color

Resolves the color of the pixel. Invalid palette values should be propagated prior to to calling this, but it isn’t guaranteed, for example if the palette pixel was manually initialized.

impl<'p> PartialEq for PalettedRgba<'p>

fn eq(&self, other: &PalettedRgba<'p>) -> 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 Pixel for PalettedRgba<'_>

const COLOR_TYPE: ColorType = ColorType::PaletteRgba

The color type of the pixel.

const BIT_DEPTH: u8 = 8

The bit depth of the pixel.

type Subpixel = u8

The type of a single component in the pixel.

type Color = Rgba

The resolved color type of the palette. This is Self for non-paletted pixels.

type Data = [u8; 1]

The iterator type this pixel uses.

fn map_subpixels<F, A>(self, f: F, a: A) -> Self

where F: Fn(Self::Subpixel) -> Self::Subpixel, A: Fn(Self::Subpixel) -> Self::Subpixel,

Maps the pixel’s components and returns a new pixel with the mapped components.

fn from_raw_parts_paletted<P: Pixel>( _color_type: ColorType, _bit_depth: u8, _data: &[u8], _palette: Option<&[P]>, ) -> Result<Self>

Creates this pixel from the given color type, bit depth, data, and possibly a color palette. This may require a lossy xonversion.

fn from_bytes(_bytes: &[u8]) -> Self

Creates this pixel from a raw bytes. This is used internally and is unchecked - it panics if the data is not of the correct length.

fn as_bytes(&self) -> Self::Data

Turns this pixel into bytes.

fn merge_with_alpha(self, other: Self, alpha: u8) -> Self

Merges this pixel with the given overlay pixel, where the alpha of the overlay pixel is known. This is used in anti-aliasing.

fn from_dynamic(_dynamic: Dynamic) -> Self

Creates this pixel from any dynamic pixel, dynamically at runtime. Different from the From/Into traits.

fn as_rgb(&self) -> Rgb

Returns this pixel as RGB despite its type. This can panic on some pixel types, you must be sure this pixel is able to be converted into RGB before using this.

fn as_rgba(&self) -> Rgba

Returns this pixel as RGBA despite its type. This can panic on some pixel types, you must be sure this pixel is able to be converted into RGBA before using this.

fn color_type(&self) -> ColorType

Resolves the color type of this pixel at runtime. This is used for dynamic color types. If you are certain the pixel is not dynamic, you can use the Self::COLOR_TYPE constant instead.

fn luminance(&self) -> u8

where Self: Into<L>,

The luminance of the pixel.

fn from_raw_parts( color_type: ColorType, bit_depth: u8, data: &[u8], ) -> Result<Self>

Creates this pixel from the given color type, bit depth, and data. This may require a lossy conversion.

fn from_arbitrary_palette<P: Pixel>(palette: &[P], index: usize) -> Result<Self>

Creates this pixel from the given palette and index, but the conversion is done at runtime.

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

Merges this pixel with the given overlay pixel, taking into account alpha.

fn overlay(self, other: Self, mode: OverlayMode) -> Self

Overlays this pixel with the given overlay pixel, abiding by the given overlay mode.

fn overlay_with_alpha(self, other: Self, mode: OverlayMode, alpha: u8) -> Self

Overlays this pixel with the given overlay pixel, abiding by the given overlay mode with the given alpha.

impl<'p> StructuralPartialEq for PalettedRgba<'p>