Struct exr::image::SpecificChannels

pub struct SpecificChannels<Pixels, ChannelsDescription> {
    pub channels: ChannelsDescription,
    pub pixels: Pixels,
}

A grid of pixels. The pixels are written to your custom pixel storage. PixelStorage can be anything, from a flat Vec<f16> to Vec<Vec<AnySample>>, as desired. In order to write this image to a file, your PixelStorage must implement GetPixel.

Fields

channels: ChannelsDescription

A description of the channels in the file, as opposed to the channels in memory. Should always be a tuple containing ChannelDescriptions, one description for each channel.

pixels: Pixels

Your custom pixel storage

Implementations

impl<SampleStorage, Channels> SpecificChannels<SampleStorage, Channels>

pub fn new(channels: Channels, source_samples: SampleStorage) -> Self

where SampleStorage: GetPixel, SampleStorage::Pixel: IntoRecursive, Channels: Sync + Clone + IntoRecursive, <Channels as IntoRecursive>::Recursive: WritableChannelsDescription<<SampleStorage::Pixel as IntoRecursive>::Recursive>,

Create some pixels with channel information. The Channels must be a tuple containing either ChannelDescription or Option<ChannelDescription>. The length of the tuple dictates the number of channels in the sample storage.

impl SpecificChannels<(), ()>

pub fn build() -> SpecificChannelsBuilder<NoneMore, NoneMore>

Start building some specific channels. On the result of this function, call with_named_channel as many times as desired, and then call with_pixels to define the colors.

impl<SampleStorage> SpecificChannels<SampleStorage, (ChannelDescription, ChannelDescription, ChannelDescription, ChannelDescription)>

pub fn rgba<R, G, B, A>(source_samples: SampleStorage) -> Self

where R: IntoSample, G: IntoSample, B: IntoSample, A: IntoSample, SampleStorage: GetPixel<Pixel = (R, G, B, A)>,

Create an image with red, green, blue, and alpha channels. You can pass a closure that returns a color for each pixel (Fn(Vec2<usize>) -> (R,G,B,A)), or you can pass your own image if it implements GetPixel<Pixel=(R,G,B,A)>. Each of R, G, B and A can be either f16, f32, u32, or Sample.

impl<SampleStorage> SpecificChannels<SampleStorage, (ChannelDescription, ChannelDescription, ChannelDescription)>

pub fn rgb<R, G, B>(source_samples: SampleStorage) -> Self

where R: IntoSample, G: IntoSample, B: IntoSample, SampleStorage: GetPixel<Pixel = (R, G, B)>,

Create an image with red, green, and blue channels. You can pass a closure that returns a color for each pixel (Fn(Vec2<usize>) -> (R,G,B)), or you can pass your own image if it implements GetPixel<Pixel=(R,G,B)>. Each of R, G and B can be either f16, f32, u32, or Sample.

Trait Implementations

impl<Pixels: Clone, ChannelsDescription: Clone> Clone for SpecificChannels<Pixels, ChannelsDescription>

fn clone(&self) -> SpecificChannels<Pixels, ChannelsDescription>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Pixels: Debug, ChannelsDescription: Debug> Debug for SpecificChannels<Pixels, ChannelsDescription>

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

Formats the value using the given formatter.

impl<Pixels: PartialEq, ChannelsDescription: PartialEq> PartialEq for SpecificChannels<Pixels, ChannelsDescription>

fn eq(&self, other: &SpecificChannels<Pixels, ChannelsDescription>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<Pxs, Chans> ValidateResult for SpecificChannels<Pxs, Chans>

where Pxs: ValidateResult, Chans: Eq,

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<'c, Channels, Storage> WritableChannels<'c> for SpecificChannels<Storage, Channels>

where Storage: 'c + GetPixel, Storage::Pixel: IntoRecursive, Channels: 'c + Sync + Clone + IntoRecursive, <Channels as IntoRecursive>::Recursive: WritableChannelsDescription<<Storage::Pixel as IntoRecursive>::Recursive>,

fn infer_channel_list(&self) -> ChannelList

Generate the file meta data for this list of channel

fn infer_level_modes(&self) -> (LevelMode, RoundingMode)

Generate the file meta data of whether and how resolution levels should be stored in the file

type Writer = SpecificChannelsWriter<'c, <<Channels as IntoRecursive>::Recursive as WritableChannelsDescription<<<Storage as GetPixel>::Pixel as IntoRecursive>::Recursive>>::RecursiveWriter, Storage, Channels>

The type of temporary writer

fn create_writer(&'c self, header: &Header) -> Self::Writer

Create a temporary writer for this list of channels

impl<Pixels: Eq, ChannelsDescription: Eq> Eq for SpecificChannels<Pixels, ChannelsDescription>

impl<Pixels, ChannelsDescription> StructuralPartialEq for SpecificChannels<Pixels, ChannelsDescription>