mi32/mg2imagefilewriter.h

Go to the documentation of this file.

#ifndef  INC_MI32_MG2IMAGEFILEWRITER_H
#define  INC_MI32_MG2IMAGEFILEWRITER_H

#ifndef  INC_MI32_STDDEFNS_H
#include <mi32/stddefns.h>
#endif

class FILEPATH;
class TRANS2D_MAPGEN;
namespace SPATREF {
   class COORDREFSYS;
   }
namespace MGD {
   class DEVICE;
   }
namespace RVC {
   class OBJITEM;
   }

namespace MGD {

class IMAGEFILEWRITER {
   public:

      class SETTINGS {
         public:

            class FORM;

            enum FORMAT {
               FORMAT_RVC =      0x00000100,
               FORMAT_GeoJP2 =   0x00000200,
               FORMAT_JP2 =      0x00000400,
               FORMAT_GeoTIFF =  0x00000800,
               FORMAT_TIFF =     0x00001000,
               FORMAT_JPEG =     0x00002000,
               FORMAT_PNG =      0x00004000,
               FORMAT_MASK =     0xFFFFFF00     // Keep low bits free so can combine with compression type.
               };

            enum COMPRESSTYPE {
               COMPRESSTYPE_None =                 0,    // RVC, TIFF
      //       COMPRESSTYPE_RLE =                  1,    // RVC
               COMPRESSTYPE_DPCM =                 2,    // RVC
               COMPRESSTYPE_Huffman =              3,    // RVC
               COMPRESSTYPE_LZW =                  4,    // TIFF
               COMPRESSTYPE_PackBits =             5,    // TIFF
               COMPRESSTYPE_JPEG_BestQuality =     6,    // RVC, JPEG
               COMPRESSTYPE_JPEG_UserQuality =     7,    // RVC, JPEG
               COMPRESSTYPE_JPEG2000_Lossless =    8,    // RVC, JP2
               COMPRESSTYPE_JPEG2000_BestQuality = 9,    // RVC, JP2
               COMPRESSTYPE_JPEG2000_UserRatio =   10,   // RVC, JP2
               };

            SETTINGS (
               );

            UINT16 GetCompressRatio (
               ) const { return (m_CompressRatio); }

            UINT16 GetCompressQuality (
               ) const { return (m_CompressQuality); }

            COMPRESSTYPE GetCompressType (
               ) const { return (m_CompressType); }

            const char* GetFileExtension (
               ) const;

            FORMAT GetFormat (
               ) const { return (m_Format); }

            bool IniRead (
               void *IniHandle,                 
               const char *group,               
               const char *field                
               );

            void IniWrite (
               void *IniHandle,                 
               const char *group,               
               const char *field                
               ) const;

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT

            FORMAT m_Format;
            COMPRESSTYPE m_CompressType;
            UINT16 m_CompressQuality;
            UINT16 m_CompressRatio;

            friend class SETTINGS::FORM;
            #endif   // GENERATING_DOXYGEN_OUTPUT
         };

      IMAGEFILEWRITER (
         const SETTINGS& settings
         );

      ~IMAGEFILEWRITER ();

      ERRVALUE Write (
         const FILEPATH& filepath,
         MGD::DEVICE& DeviceSrc,
         const TRANS2D_MAPGEN *pTransToCRS = 0,
         bool UseXasAlpha = false
         );

      ERRVALUE Write (
         RVC::OBJITEM& objitem,              
         MGD::DEVICE& DeviceSrc,
         const TRANS2D_MAPGEN *pTransToCRS = 0,
         bool UseXasAlpha = false
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      SETTINGS m_Settings;
      #endif
   };




}  // End namespace MGD
#endif   // INC_MI32_MG2IMAGEFILEWRITER_H

---