Struct tiff::encoder::ImageEncoder

pub struct ImageEncoder<'a, W: 'a + Write + Seek, C: ColorType, K: TiffKind, D: Compression = Uncompressed> {
    encoder: DirectoryEncoder<'a, W, K>,
    strip_idx: u64,
    strip_count: u64,
    row_samples: u64,
    width: u32,
    height: u32,
    rows_per_strip: u64,
    strip_offsets: Vec<K::OffsetType>,
    strip_byte_count: Vec<K::OffsetType>,
    dropped: bool,
    compression: D,
    _phantom: PhantomData<C>,
}

Type to encode images strip by strip.

You should call finish on this when you are finished with it. Encoding can silently fail while this is dropping.

Examples

use tiff::encoder::*;
use tiff::tags::Tag;

let mut tiff = TiffEncoder::new(&mut file).unwrap();
let mut image = tiff.new_image::<colortype::RGB8>(100, 100).unwrap();

// You can encode tags here
image.encoder().write_tag(Tag::Artist, "Image-tiff").unwrap();

// Strip size can be configured before writing data
image.rows_per_strip(2).unwrap();

let mut idx = 0;
while image.next_strip_sample_count() > 0 {
    let sample_count = image.next_strip_sample_count() as usize;
    image.write_strip(&image_data[idx..idx+sample_count]).unwrap();
    idx += sample_count;
}
image.finish().unwrap();

You can also call write_data function wich will encode by strip and finish

Fields

encoder: DirectoryEncoder<'a, W, K>

strip_idx: u64

strip_count: u64

row_samples: u64

width: u32

height: u32

rows_per_strip: u64

strip_offsets: Vec<K::OffsetType>

strip_byte_count: Vec<K::OffsetType>

dropped: bool

compression: D

_phantom: PhantomData<C>

Implementations

impl<'a, W: 'a + Write + Seek, T: ColorType, K: TiffKind, D: Compression> ImageEncoder<'a, W, T, K, D>

fn new( encoder: DirectoryEncoder<'a, W, K>, width: u32, height: u32, ) -> TiffResult<Self>

where D: Default,

fn with_compression( encoder: DirectoryEncoder<'a, W, K>, width: u32, height: u32, compression: D, ) -> TiffResult<Self>

pub fn next_strip_sample_count(&self) -> u64

Number of samples the next strip should have.

pub fn write_strip(&mut self, value: &[T::Inner]) -> TiffResult<()>

where [T::Inner]: TiffValue,

Write a single strip.

pub fn write_data(self, data: &[T::Inner]) -> TiffResult<()>

where [T::Inner]: TiffValue,

Write strips from data

pub fn resolution(&mut self, unit: ResolutionUnit, value: Rational)

Set image resolution

pub fn resolution_unit(&mut self, unit: ResolutionUnit)

Set image resolution unit

pub fn x_resolution(&mut self, value: Rational)

Set image x-resolution

pub fn y_resolution(&mut self, value: Rational)

Set image y-resolution

pub fn rows_per_strip(&mut self, value: u32) -> TiffResult<()>

Set image number of lines per strip

This function needs to be called before any calls to write_data or write_strip and will return an error otherwise.

fn finish_internal(&mut self) -> TiffResult<()>

pub fn encoder(&mut self) -> &mut DirectoryEncoder<'a, W, K>

Get a reference of the underlying DirectoryEncoder

pub fn finish(self) -> TiffResult<()>

Write out image and ifd directory.

Trait Implementations

impl<'a, W: Write + Seek, C: ColorType, K: TiffKind, D: Compression> Drop for ImageEncoder<'a, W, C, K, D>

fn drop(&mut self)

Executes the destructor for this type.