1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
//! A crate for encoding TIFF files. //! //! This crate allows to create any hierarchy of IFDs and to add any //! tags with any values to each. It does so while avoiding that //! the user needs to worry about the position of each structure in the //! file and to point to it with the correct offset. //! //! The main structure of this crate, used to actually write the TIFF //! file, is the [`TiffFile`]. This structure writes the file in [little endian] //! by default (but that can be changed) and requires an [`IfdChain`]. This //! `IfdChain` consists of the first [`Ifd`] of the file, the one it points to (if any), //! and so on. Each `Ifd` has one or more entries, which are represented //! by a pair of [`FieldTag`] and [`FieldValues`]. //! //! # Examples //! //! Creating a 256x256 bilevel image with every pixel black. //! //! ``` //! #[macro_use] //! extern crate tiff_encoder; //! use tiff_encoder::prelude::*; //! use tiff_encoder::ifd::tags; //! //! # fn main() { //! // 256*256/8 = 8192 //! // The image data will have 8192 bytes with 0 in every bit (each representing a //! // black pixel). //! let image_data = vec![0x00; 8192]; //! //! TiffFile::new( //! Ifd::new() //! .with_entry(tags::PhotometricInterpretation, SHORT![1]) // Black is zero //! .with_entry(tags::Compression, SHORT![1]) // No compression //! //! .with_entry(tags::ImageLength, LONG![256]) //! .with_entry(tags::ImageWidth, LONG![256]) //! //! .with_entry(tags::ResolutionUnit, SHORT![1]) // No resolution unit //! .with_entry(tags::XResolution, RATIONAL![(1, 1)]) //! .with_entry(tags::YResolution, RATIONAL![(1, 1)]) //! //! .with_entry(tags::RowsPerStrip, LONG![256]) // One strip for the whole image //! .with_entry(tags::StripByteCounts, LONG![8192]) //! .with_entry(tags::StripOffsets, ByteBlock::single(image_data)) //! .single() // This is the only Ifd in its IfdChain //! ).write_to("example.tif").unwrap(); //! # } //! ``` //! //! [`TiffFile`]: struct.TiffFile.html //! [little endian]: write/enum.Endianness.html#variant.II //! [`Ifd`]: ifd/struct.Ifd.html //! [`IfdChain`]: ifd/struct.IfdChain.html //! [`FieldTag`]: ifd/tags/type.FieldTag.html //! [`FieldValues`]: ifd/values/trait.FieldValues.html extern crate byteorder; pub mod ifd; pub mod write; mod file; pub use file::TiffFile; /// Common imports that are necessary for almost every use of the `tiff_encoder` /// library. /// /// # Usage /// ``` /// use tiff_encoder::prelude::*; /// ``` /// /// # Other common imports /// /// The following imports, although also often used for this library, are not /// included in the prelude to avoid polluting the user's namespace. /// /// ``` /// use tiff_encoder::write; // Helpers to write data to the file, particularly `Datablock` /// use tiff_encoder::ifd::tags; // Constants for common tags in IFD entries /// ``` /// /// Note that `macro_rules!` for using [`ifd::types`] cannot (unfortunately) be re-exported /// in the prelude. This means you'll either have to explicitely import them or use `#[macro_use]`. /// /// ``` /// // Either /// #[macro_use] /// extern crate tiff_encoder; /// /// // Or /// use tiff_encoder::{ /// ASCII, BYTE, DOUBLE, FLOAT, LONG, RATIONAL, /// SBYTE, SHORT, SLONG, SRATIONAL, SSHORT, UNDEFINED /// }; /// /// # fn main() {} /// ``` /// /// [`ifd::types`]: ../ifd/types/index.html pub mod prelude { #[doc(no_inline)] pub use crate::ifd::Ifd; #[doc(no_inline)] pub use crate::ifd::IfdChain; #[doc(no_inline)] pub use crate::write::ByteBlock; #[doc(no_inline)] pub use crate::TiffFile; }