[][src]Struct image::io::Reader

pub struct Reader<R: Read> { /* fields omitted */ }

A multi-format image reader.

Wraps an input reader to facilitate automatic detection of an image's format, appropriate decoding method, and dispatches into the set of supported ImageDecoder implementations.


Opening a file, deducing the format based on the file path automatically, and trying to decode the image contained can be performed by constructing the reader and immediately consuming it.

let image = Reader::open("path/to/image.png")?

It is also possible to make a guess based on the content. This is especially handy if the source is some blob in memory and you have constructed the reader in another way. Here is an example with a pnm black-and-white subformat that encodes its pixel matrix with ascii values.

use std::io::Cursor;
use image::ImageFormat;

let raw_data = b"P1 2 2\n\
    0 1\n\
    1 0\n";

let mut reader = Reader::new(Cursor::new(raw_data))
    .expect("Cursor io never fails");
assert_eq!(reader.format(), Some(ImageFormat::PNM));

let image = reader.decode()?;

As a final fallback or if only a specific format must be used, the reader always allows manual specification of the supposed image format with set_format.


impl<R: Read> Reader<R>[src]

pub fn new(reader: R) -> Self[src]

Create a new image reader without a preset format.

It is possible to guess the format based on the content of the read object with guess_format, or to set the format directly with set_format.

pub fn with_format(reader: R, format: ImageFormat) -> Self[src]

Construct a reader with specified format.

pub fn format(&self) -> Option<ImageFormat>[src]

Get the currently determined format.

pub fn set_format(&mut self, format: ImageFormat)[src]

Supply the format as which to interpret the read image.

pub fn clear_format(&mut self)[src]

Remove the current information on the image format.

Note that many operations require format information to be present and will return e.g. an ImageError::UnsupportedError when the image format has not been set.

pub fn into_inner(self) -> R[src]

Unwrap the reader.

impl Reader<BufReader<File>>[src]

pub fn open<P>(path: P) -> Result<Self> where
    P: AsRef<Path>, 

Open a file to read, format will be guessed from path.

This will not attempt any io operation on the opened file.

If you want to inspect the content for a better guess on the format, which does not depend on file extensions, follow this call with a call to guess_format.

impl<R: BufRead + Seek> Reader<R>[src]

pub fn with_guessed_format(self) -> Result<Self>[src]

Make a format guess based on the content, replacing it on success.

Returns Ok with the guess if no io error occurs. Additionally, replaces the current format if the guess was successful. If the guess was not unable to determine a format then the current format of the reader is unchanged.

Returns an error if the underlying reader fails. The format is unchanged. The error is a std::io::Error and not ImageError since the only error case is an error when the underlying reader seeks.

When an error occurs, the reader may not have been properly reset and it is potentially hazardous to continue with more io.


This supplements the path based type deduction from [open] with content based deduction. This is more common in Linux and UNIX operating systems and also helpful if the path can not be directly controlled.

let image = Reader::open("image.unknown")?

pub fn into_dimensions(self) -> ImageResult<(u32, u32)>[src]

Read the image dimensions.

Uses the current format to construct the correct reader for the format.

If no format was determined, returns an ImageError::UnsupportedError.

pub fn decode(self) -> ImageResult<DynamicImage>[src]

Read the image (replaces load).

Uses the current format to construct the correct reader for the format.

If no format was determined, returns an ImageError::UnsupportedError.

Auto Trait Implementations

impl<R> Send for Reader<R> where
    R: Send

impl<R> Unpin for Reader<R> where
    R: Unpin

impl<R> Sync for Reader<R> where
    R: Sync

impl<R> UnwindSafe for Reader<R> where
    R: UnwindSafe

impl<R> RefUnwindSafe for Reader<R> where
    R: RefUnwindSafe

Blanket Implementations

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

impl<T> From<T> for T[src]

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

type Error = Infallible

The type returned in the event of a conversion error.

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

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> BorrowMut<T> for T where
    T: ?Sized

impl<T> Borrow<T> for T where
    T: ?Sized

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

impl<T> SetParameter for T[src]