tiff.hh

Go to the documentation of this file.

#pragma once
#include <memory>
#include <fstream>
#include <vector>
#include <tuple>
#include <map>

class Tiff
{
    std::shared_ptr<std::ifstream> sp; 
    bool le; 
    bool efix; 
    uint32_t ifd; 
    // read from stream
    uint16_t read16();
    uint32_t read32();
public:
    struct DEntry
    {
        uint16_t tag; 
        uint16_t type; 
        uint32_t count; 
        uint32_t data; 
    };
private:
    DEntry read_dentry(); // endian is corrected
    uint16_t get16(DEntry const & e) {return le?e.data&0xffff:e.data>>16;} // first uint16
    uint16_t next16(DEntry const & e) {return le?e.data>>16:e.data&0xffff;} // second uint16
    uint32_t to32(DEntry const & e);
    std::string get_str(DEntry const & de);
    std::vector<uint16_t> get16s(DEntry const & e);
    std::vector<uint32_t> get32s(DEntry const & e); 
    std::tuple<uint32_t,uint32_t> get_ratio(DEntry const & e);
public:
    Tiff(std::shared_ptr<std::ifstream> s) : sp(s) {}
    void start(); 
    uint32_t parse_ifd(
        uint32_t i = 0 
    ); 
    std::vector<char> read_image(); 
    enum Tag {
        Tag_ImageWidth = 0x100,
        Tag_ImageLength = 0x101,
        Tag_BitsPerSample = 0x102,
        Tag_Compression = 0x103,
        Tag_PhotometricInterpretation = 0x106,
        Tag_FillOrder = 0x10a,
        Tag_ImageDescription = 0x10e,
        Tag_StripOffsets = 0x111,
        Tag_Orientation = 0x112,
        Tag_SamplesPerPixel = 0x115,
        Tag_RowsPerStrip = 0x116,
        Tag_StripByteCounts = 0x117,
        Tag_XResolution = 0x11a,
        Tag_YResolution = 0x11b,
        Tag_PlanarConfiguration = 0x11c,
        Tag_ResolutionUnit = 0x128,
        Tag_Software = 0x131,
        Tag_SampleFormat = 0x153,
        Tag_ImageID = 0x800d
    };
    enum Compression {
        Cmp_None = 1,
        Cmp_CCITT = 2,
        Cmp_PackBits = 32773
    };
    std::map<Compression,std::string> const compress_name {
        {Cmp_None,"None"},
        {Cmp_CCITT,"CCITT"},
        {Cmp_PackBits,"PackBits"}
    };
    enum Photometric {
        Ptm_WhiteIsZero = 0,
        Ptm_BlackIsZero = 1,
        Ptm_RGB = 2,
        Ptm_Palette = 3,
        Ptm_TransparencyMask = 4
    };
    std::map<Photometric,std::string> const photom_name {
        {Ptm_WhiteIsZero,"WhiteIsZero"},
        {Ptm_BlackIsZero,"BlackIsZero"},
        {Ptm_RGB,"RGB"},
        {Ptm_Palette,"Palette"},
        {Ptm_TransparencyMask,"TransparencyMask"}
    };
    enum Unit {
        Unt_None = 1,
        Unt_Inch = 2,
        Unt_Centimeter = 3
    };
    std::map<Unit,std::string> const unit_name {
        {Unt_None,"None"},
        {Unt_Inch,"Inch"},
        {Unt_Centimeter,"Centimeter"}
    };
    enum SampleFormat {
        Fmt_Unsigned = 1,
        Fmt_TwoComplement = 2,
        Fmt_IEEEFloat = 3,
        Fmt_Undefined = 4
    };
    std::map<SampleFormat,std::string> const format_name {
        {Fmt_Unsigned,"Unsigned"},
        {Fmt_TwoComplement,"TwoComplement"},
        {Fmt_IEEEFloat,"IEEEFloat"},
        {Fmt_Undefined,"Undefined"}
    };
    uint32_t image_width; 
    uint32_t image_length; 
    std::vector<uint16_t> bits_per_sample; 
    Compression compression; 
    Photometric photometric; 
    uint16_t fill_order; 
    std::string image_description; 
    std::vector<uint32_t> strip_offsets; 
    uint16_t orientation; 
    uint16_t samples_per_pixel; 
    uint32_t rows_per_strip; 
    std::vector<uint32_t> strip_byte_counts; 
    std::tuple<uint32_t,uint32_t> xresolution; 
    std::tuple<uint32_t,uint32_t> yresolution; 
    uint16_t planar_configuration; 
    Unit resolution_unit; 
    std::string software; 
    std::vector<SampleFormat> sample_formats; 
    std::string image_id; 
};