Struct AnyChannel

pub struct AnyChannel<Samples> { pub name: Text, pub sample_data: Samples, pub quantize_linearly: bool, pub sampling: Vec2<usize> }

A single arbitrary channel. Samples can currently only be FlatSamples or Levels<FlatSamples>

Fields

name: Text

One of "R", "G", or "B" most of the time.

sample_data: Samples

The actual pixel data. Can be FlatSamples or Levels<FlatSamples>.

quantize_linearly: bool

This attribute only tells lossy compression methods whether this value should be quantized exponentially or linearly.

Should be false for red, green, blue and luma channels, as they are not perceived linearly. Should be true for hue, chroma, saturation, and alpha channels.

sampling: Vec2<usize>

How many of the samples are skipped compared to the other channels in this layer.

Can be used for chroma subsampling for manual lossy data compression. Values other than 1 are allowed only in flat, scan-line based images. If an image is deep or tiled, the sampling rates for all of its channels must be 1.

Implementations

impl<'s, SampleData: 's> AnyChannel<SampleData>

fn new(name: impl Into<Text>, sample_data: SampleData) -> Self
where
    SampleData: WritableSamples<'s>,

Create a new channel without subsampling.

Automatically flags this channel for specialized compression if the name is "R", "G", "B", "Y", or "L", as they typically encode values that are perceived non-linearly. Construct the value yourself using AnyChannel { .. }, if you want to control this flag.

Trait Implementations

impl<S> ValidateResult for AnyChannel<S> where S: ValidateResult,

fn validate_result(&self, other: &Self, options: ValidationOptions, location: impl Fn() -> String) -> ValidationResult

impl<Samples: Clone> Clone for AnyChannel<Samples>

fn clone(&self) -> Self

impl<Samples: Debug> Debug for AnyChannel<Samples>

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

impl<Samples: Eq> Eq for AnyChannel<Samples>

impl<Samples: PartialEq> PartialEq for AnyChannel<Samples>

fn eq(&self, other: &Self) -> bool

impl<Samples: PartialEq> StructuralPartialEq for AnyChannel<Samples>

Auto Trait Implementations

impl<Samples> Freeze for AnyChannel<Samples> where Samples: Freeze,

impl<Samples> RefUnwindSafe for AnyChannel<Samples> where Samples: RefUnwindSafe,

impl<Samples> Send for AnyChannel<Samples> where Samples: Send,

impl<Samples> Sync for AnyChannel<Samples> where Samples: Sync,

impl<Samples> Unpin for AnyChannel<Samples> where Samples: Unpin,

impl<Samples> UnsafeUnpin for AnyChannel<Samples> where Samples: UnsafeUnpin,

impl<Samples> UnwindSafe for AnyChannel<Samples> where Samples: UnwindSafe,

Blanket Implementations

impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for AnyChannel<Samples> where ST: ?Sized, DT: ?Sized,

impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for AnyChannel<Samples> where ST: ?Sized, DT: ?Sized,

impl<T> Any for AnyChannel<Samples> where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for AnyChannel<Samples> where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for AnyChannel<Samples> where T: ?Sized,

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

impl<T> CloneToUninit for AnyChannel<Samples> where T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

impl<T> From<T> for AnyChannel<Samples>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> Pointable for AnyChannel<Samples>

const ALIGN: usize = _;
type Init = T;
unsafe fn init(init: <T as Pointable>::Init) -> usize
unsafe fn deref<'a>(ptr: usize) -> &'a T
unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
unsafe fn drop(ptr: usize)

impl<T> Read<Exclusive, BecauseExclusive> for AnyChannel<Samples> where T: ?Sized,

impl<T> ToOwned for AnyChannel<Samples> where T: Clone,

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

impl<T, U> Into<U> for AnyChannel<Samples> where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom<U> for AnyChannel<Samples> where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for AnyChannel<Samples> where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>