Struct exr::image::read::image::ReadImage

pub struct ReadImage<OnProgress, ReadLayers> { /* private fields */ }

Specify whether to read the image in parallel, whether to use pedantic error handling, and a callback for the reading progress.

Implementations

impl<F, L> ReadImage<F, L> where
    F: FnMut(f64), 

pub fn new(read_layers: L, on_progress: F) -> Self

Uses relaxed error handling and parallel decompression.

pub fn pedantic(self) -> Self

Specify that any missing or unusual information should result in an error. Otherwise, exrs will try to compute or ignore missing information.

If pedantic is true, then an error will be returned as soon as anything is missing in the file, or two values in the image contradict each other. If pedantic is false, then only fatal errors will be thrown. By default, reading an image is not pedantic, which means that slightly invalid files might still be readable. For example, if some attribute is missing but can be recomputed, this flag decides whether an error is thrown. Or if the pedantic flag is true and there are still bytes left after the decompression algorithm finished, an error is thrown, because this should not happen and something might be wrong with the file. Or if your application is a target of attacks, or if you want to emulate the original C++ library, you might want to switch to pedantic reading.

pub fn non_parallel(self) -> Self

Specify that multiple pixel blocks should never be decompressed using multiple threads at once. This might be slower but uses less memory and less synchronization.

pub fn on_progress<OnProgress>(
    self,
    on_progress: OnProgress
) -> ReadImage<OnProgress, L> where
    OnProgress: FnMut(f64), 

Specify a function to be called regularly throughout the loading process. Replaces all previously specified progress functions in this reader.

pub fn from_file<Layers>(self, path: impl AsRef<Path>) -> Result<Image<Layers>> where
    for<'s> L: ReadLayers<'s, Layers = Layers>, 

Read the exr image from a file. Use [ReadImage::read_from_unbuffered] instead, if you do not have a file.

pub fn from_unbuffered<Layers>(
    self,
    unbuffered: impl Read + Seek
) -> Result<Image<Layers>> where
    for<'s> L: ReadLayers<'s, Layers = Layers>, 

Buffer the reader and then read the exr image from it. Use [ReadImage::read_from_buffered] instead, if your reader is an in-memory reader. Use [ReadImage::read_from_file] instead, if you have a file path.

pub fn from_buffered<Layers>(
    self,
    buffered: impl Read + Seek
) -> Result<Image<Layers>> where
    for<'s> L: ReadLayers<'s, Layers = Layers>, 

Read the exr image from a buffered reader. Use [ReadImage::read_from_file] instead, if you have a file path. Use [ReadImage::read_from_unbuffered] instead, if this is not an in-memory reader.

pub fn from_chunks<Layers>(
    self,
    chunks_reader: Reader<impl Read + Seek>
) -> Result<Image<Layers>> where
    for<'s> L: ReadLayers<'s, Layers = Layers>, 

Read the exr image from an initialized chunks reader that has already extracted the meta data from the file. Use [ReadImage::read_from_file] instead, if you have a file path. Use [ReadImage::read_from_buffered] instead, if this is an in-memory reader.

Trait Implementations

impl<OnProgress: Clone, ReadLayers: Clone> Clone for ReadImage<OnProgress, ReadLayers>

fn clone(&self) -> ReadImage<OnProgress, ReadLayers>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<OnProgress: Debug, ReadLayers: Debug> Debug for ReadImage<OnProgress, ReadLayers>

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

Formats the value using the given formatter.