Struct exr::image::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>

pub 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<Samples: Clone> Clone for AnyChannel<Samples>

fn clone(&self) -> AnyChannel<Samples>

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

fn eq(&self, other: &AnyChannel<Samples>) -> 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<S> ValidateResult for AnyChannel<S>

where S: ValidateResult,

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

Compare self with the other. Exceptional behaviour:

fn assert_equals_result(&self, result: &Self)

Compare self with the other. Panics if not equal.

impl<Samples> StructuralPartialEq for AnyChannel<Samples>