mi32/tiffext.h

Go to the documentation of this file.

#ifndef  INC_MI32_TIFFEXT_H
#define  INC_MI32_TIFFEXT_H

#ifndef  INC_MI32_FILERAW_H
   #include <mi32/fileraw.h>
#endif

#ifndef INC_MI32_GENERICRWMEM_H
   #include <mi32/genericrwmem.h>
#endif

#ifndef  INC_MI32_COLOR_H
   #include <mi32/color.h>
#endif

#ifndef  INC_MI32_CTRLPT_H
   #include <mi32/ctrlpt.h>
#endif

#ifndef  INC_MI32_MISTRING_H
   #include <mi32/mistring.h>
#endif

#ifdef RVCSYSDLL
   #define CLASSLIBEXPORT MI_DLLCLASSEXPORT
#else
   #define CLASSLIBEXPORT MI_DLLCLASSIMPORT
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT
class TRANS2D_AFFINE;
namespace SPATREF {
   class COORDREFSYS;
   }
#endif

//===================================================================================================================

class CLASSLIBEXPORT TIFFEXT {
   public:

      enum SUBTYPEFLAGS {
         SUBTYPEFLAG_None =            0x00,
         SUBTYPEFLAG_ReducedImage =    0x01,
         SUBTYPEFLAG_Page =            0x02,
         SUBTYPEFLAG_Mask =            0x04
         };

      enum COMPRESSION {
         COMPRESSION_None =         1,       
         COMPRESSION_CCITT_RLE =    2,       
         COMPRESSION_CCITT_FAX3 =   3,       
         COMPRESSION_CCITT_FAX4 =   4,       
         COMPRESSION_L_Z_W =        5,       
         COMPRESSION_OldJPEG =      6,       
         COMPRESSION_JPEG_DCT =     7,       
         COMPRESSION_NeXT =         32766,   
         COMPRESSION_CCITT_RLEW =   32771,   
         COMPRESSION_PackBits =     32773,   
         COMPRESSION_ThunderScan =  32809    
         };

      enum PHOTOMETRIC {
         PHOTOMETRIC_MinIsWhite =   0,
         PHOTOMETRIC_MinIsBlack =   1,
         PHOTOMETRIC_RedGreenBlue = 2,
         PHOTOMETRIC_Palette =      3,
         PHOTOMETRIC_Mask =         4,
         PHOTOMETRIC_Separated =    5,
         PHOTOMETRIC_YCbCr =        6,
         PHOTOMETRIC_CIE_Lab =      8,
         PHOTOMETRIC_ITU_Lab =      10,
         PHOTOMETRIC_CMYK =         65530
         };

      enum PLANARCONFIG {
         PLANARCONFIG_Contiguous =  1,
         PLANARCONFIG_Separate =    2
         };

      enum RESOLUTIONUNIT {
         RESOLUTIONUNIT_Inch =         2,
         RESOLUTIONUNIT_Centimeter =   3
         };

      enum SAMPLEFORMAT {
         SAMPLEFORMAT_Unsigned =       1,
         SAMPLEFORMAT_Signed =         2,
         SAMPLEFORMAT_Float =          3,
         SAMPLEFORMAT_Undefined =      4,
         SAMPLEFORMAT_ComplexInt =     5,
         SAMPLEFORMAT_ComplexFloat =   6
         };

      #ifndef GENERATING_DOXYGEN_OUTPUT
      class IMAGEINFO;
      class IMAGEINFO_PRIV;
      #endif // GENERATING_DOXYGEN_OUTPUT

      void AddRef (
         );

      int GetDefaultImageIdx (
         ) const;

      IMAGEINFO GetImageInfo (
         ) const;

      int GetNumImages (
         ) const;

      int GetOpenImageIdx (
         ) const;

      int MakeImage (
         const IMAGEINFO& imageinfo             
         );

      ERRVALUE OpenImage (
         UINT16 ImageIdx
         );

      int ReadContrastTable (
         SIMPLE_ARRAY<UINT8>& table             
         );

      int ReadGeoreference (
         SPATREF::COORDREFSYS& CoordRefSys,     
         TRANS2D_AFFINE& TransAffine,           
         SIMPLE_ARRAY<CTRLPOINT3>& CtrlPoints   
         );

      // Read metadata (properties from header).
      ERRVALUE ReadMetadata (
         MISTRING& string                       
         );

      int ReadPalette (
         COLOR_ARRAY& palette       
         );

      ERRVALUE ReadPixels (
         INT32 sample,                       
         INT32 line,                         
         INT32 column,                       
         INT32 numpixels,                    
         void *buffer,                       
         bool leavepacked = false            
         );

      bool Release (
         );

      void SetWriteUserDefinedCRS (
         bool WriteUserDefinedCRS = true
         );

      ERRVALUE WriteContrast (
         UINT16 MaxValue,  
         UINT16 MinValue      
         );

      ERRVALUE WriteGeoreference (
         const SPATREF::COORDREFSYS& CoordRefSys,  
         const TRANS2D_AFFINE& TransAffine,
         bool ForceNonRotated = false
         );

      ERRVALUE WriteGeoreference (
         const SPATREF::COORDREFSYS& CoordRefSys,  
         const CTRLPOINT3 *CtrlPoints,
         int NumCtrlPoints,
         bool ForceNonRotated = false
         );

      ERRVALUE WriteGeoreference (
         const SPATREF::COORDREFSYS& CoordRefSys,  
         const SIMPLE_ARRAY<CTRLPOINT3>& CtrlPoints,
         bool ForceNonRotated = false
         );

      ERRVALUE WritePalette (
         const COLOR_ARRAY& palette
         );

      ERRVALUE WritePixels (
         INT32 sample,                       
         INT32 line,                         
         INT32 column,                       
         INT32 numpixels,                    
         const void *buffer,                 
         bool prepacked = false              
         );

   protected:

      enum OPENMODE {
         OPENMODE_Read = 0,
         OPENMODE_Write = 1
         };

      TIFFEXT ();

      virtual ~TIFFEXT ();

      ERRVALUE CloseTIFF ();

      ERRVALUE OpenTIFF (
         GENERICRW *pGenRW,            
         const MIUNICODE *name,           
         OPENMODE openmode,               
         bool IsBigTiff = false
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      class PRIV;
      PRIV *m_pPriv;

      TIFFEXT (const TIFFEXT&);
      TIFFEXT& operator= (const TIFFEXT&);
      friend class TIFFEXT::PRIV;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(TIFFEXT::SUBTYPEFLAGS)
#endif


//===================================================================================================================

class CLASSLIBEXPORT TIFFEXT::IMAGEINFO {
   public:

      IMAGEINFO (
         INT32 ImageLength,                  
         INT32 ImageWidth,                   
         UINT16 SamplesPerPixel,             
         UINT16 BitsPerSample,               
         SAMPLEFORMAT SampleFormat = SAMPLEFORMAT_Unsigned  
         );

      #ifndef GENERATING_DOXYGEN_OUTPUT
      IMAGEINFO (IMAGEINFO_PRIV*);
      #endif // GENERATING_DOXYGEN_OUTPUT

      IMAGEINFO (
         const IMAGEINFO& rhs
         );

      ~IMAGEINFO (
         );

      IMAGEINFO& operator= (
         const IMAGEINFO& rhs
         );

      UINT16 GetBitsPerSample (
         ) const;

      COMPRESSION GetCompression (
         ) const;

      MISTRING GetDescription (
         ) const;

      INT32 GetImageLength (
         ) const;

      INT32 GetImageWidth (
         ) const;

      PHOTOMETRIC GetPhotometric (
         ) const;

      PLANARCONFIG GetPlanarConfig (
         ) const;

      SAMPLEFORMAT GetSampleFormat (
         ) const;

      MISTRING GetSampleName (
         INT16 sample                        
         ) const;

      UINT16 GetSamplesPerPixel (
         ) const;

      INT32 GetSegmentLength (
         ) const;

      INT32 GetSegmentWidth (
         ) const;

      SUBTYPEFLAGS GetSubTypeFlags (
         ) const;

      bool IsTiled (
         ) const;

      void SetCompression (
         COMPRESSION compression
         );

      void SetDescription (
         const MISTRING& desc
         );

      void SetPhotometric (
         PHOTOMETRIC photometric
         );

      void SetPlanarConfig (
         PLANARCONFIG PlanarConfig
         );

      void SetResolution (
         double xres,
         double yres,
         RESOLUTIONUNIT resunit
         );

      void SetSegmentSize (
         INT32 SegmentLength,
         INT32 SegmentWidth
         );

      void SetSubTypeFlags (
         SUBTYPEFLAGS SubTypeFlags
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      IMAGEINFO_PRIV *m_pPriv;
      void GetExclusive();
      friend class TIFFEXT;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//===================================================================================================================

class CLASSLIBEXPORT TIFFEXT_FILE : public TIFFEXT {
   public:

      TIFFEXT_FILE ();

      ~TIFFEXT_FILE ();

      ERRVALUE Close ();

      FILEPATH GetPath () const;

      ERRVALUE Make (
         const FILEPATH& filepath,
         bool IsBigTiff = false
         );

      ERRVALUE Open (
         const FILEPATH& filepath
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      FILE_RAW m_file;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

class CLASSLIBEXPORT TIFFEXT_MEM : public TIFFEXT {
   public:

      TIFFEXT_MEM ();

      ~TIFFEXT_MEM ();

      ERRVALUE Close ();

      const UINT8* GetBuffer (
         ) const;

      INT64 GetBufferSize (
         ) const;

      UINT8* Detach (
         );

      ERRVALUE Make (
         UINT8*& buf,
         UINT32 bufsize
         );

      ERRVALUE Open (
         UINT8*& buf,
         UINT32 bufsize
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      GENERICRW_MEMORY m_mem;
      #endif
   };

//===================================================================================================================

#undef   CLASSLIBEXPORT

#endif   // INC_MI32_TIFFEXT_H

---