Struct PnmEncoder

pub struct PnmEncoder<W: Write> { /* private fields */ }

Encodes images to any of the pnm image formats.

Implementations

impl<W: Write> PnmEncoder<W>

fn new(writer: W) -> Self

Create new PnmEncoder from the writer.

The encoded images will have some pnm format. If more control over the image type is required, use either one of with_subtype or with_header. For more information on the behaviour, see with_dynamic_header.

fn with_subtype(self, subtype: PnmSubtype) -> Self

Encode a specific pnm subtype image.

The magic number and encoding type will be chosen as provided while the rest of the header data will be generated dynamically. Trying to encode incompatible images (e.g. encoding an RGB image as Graymap) will result in an error.

This will overwrite the effect of earlier calls to with_header and with_dynamic_header.

fn with_header(self, header: PnmHeader) -> Self

Enforce the use of a chosen header.

While this option gives the most control over the actual written data, the encoding process will error in case the header data and image parameters do not agree. It is the users obligation to ensure that the width and height are set accordingly, for example.

Choose this option if you want a lossless decoding/encoding round trip.

This will overwrite the effect of earlier calls to with_subtype and with_dynamic_header.

fn with_dynamic_header(self) -> Self

Create the header dynamically for each image.

This is the default option upon creation of the encoder. With this, most images should be encodable but the specific format chosen is out of the users control. The pnm subtype is chosen arbitrarily by the library.

This will overwrite the effect of earlier calls to with_subtype and with_header.

fn encode<'s, S>(&mut self, image: S, width: u32, height: u32, color: ExtendedColorType) -> ImageResult<()>
where
    S: Into<FlatSamples<'s>>,

Encode an image whose samples are represented as a sequence of u8 or u16 data.

If image is a slice of u8, the samples will be interpreted based on the chosen color option. Color types of 16-bit precision means that the bytes are reinterpreted as 16-bit samples, otherwise they are treated as 8-bit samples. If image is a slice of u16, the samples will be interpreted as 16-bit samples directly.

Some pnm subtypes are incompatible with some color options, a chosen header most certainly with any deviation from the original decoded image.

Trait Implementations

impl<W: Write> ImageEncoder for PnmEncoder<W>

fn write_image(self, buf: &[u8], width: u32, height: u32, color_type: ExtendedColorType) -> ImageResult<()>

Auto Trait Implementations

impl<W> Freeze for PnmEncoder<W> where W: Freeze,

impl<W> RefUnwindSafe for PnmEncoder<W> where W: RefUnwindSafe,

impl<W> Send for PnmEncoder<W> where W: Send,

impl<W> Sync for PnmEncoder<W> where W: Sync,

impl<W> Unpin for PnmEncoder<W> where W: Unpin,

impl<W> UnsafeUnpin for PnmEncoder<W> where W: UnsafeUnpin,

impl<W> UnwindSafe for PnmEncoder<W> where W: UnwindSafe,

Blanket Implementations

impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for PnmEncoder<W> where ST: ?Sized, DT: ?Sized,

impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for PnmEncoder<W> where ST: ?Sized, DT: ?Sized,

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

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for PnmEncoder<W> where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for PnmEncoder<W> where T: ?Sized,

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

impl<T> From<T> for PnmEncoder<W>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> IntoEither for PnmEncoder<W>

impl<T> Pointable for PnmEncoder<W>

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 PnmEncoder<W> where T: ?Sized,

impl<T, U> Into<U> for PnmEncoder<W> 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 PnmEncoder<W> where U: Into<T>,

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

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

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