mie/image.h

Go to the documentation of this file.

#ifndef INC_MIE_IMAGE_H
#define INC_MIE_IMAGE_H

#ifndef INC_MIE_GEOSPATIAL_H
   #include <mie/geospatial.h>
#endif

#ifndef INC_RVC_IMAGE_H
   #include <rvc/image.h>
#endif


namespace MIE {

// ************************************************************************

// The base class for an individual import/export job
class JOB_IMAGE : public JOB_GEOSPATIAL {
   public:
      enum MIEINTERLEAVE {
         MIEINTERLEAVE_Line = 0,
         MIEINTERLEAVE_Band = 1,
         MIEINTERLEAVE_Pixel = 2
         };

      enum FLIP {
         FLIP_None = 0,
         FLIP_Vert = 1,
         FLIP_Horz = 2,
         FLIP_Both = 3
         };

      JOB_IMAGE (
         const FORMAT& format,
         const SETTINGS& settings
         );

      virtual ~JOB_IMAGE ();

      static void CopyBits (
         const UINT8 *sbuf,   
         int soff,            
         UINT8 *dbuf,         
         int doff,            
         int len              
         );


      void ScaleBuffer (
         void* buf
         );

      static void SwapBytes (
         UINT8* buf,
         int len,
         int numbits
         );

      void GetBandPIL (
         UINT8* dbuf,
         const UINT8* sbuf,
         int band,
         int outcols
         );

      static void GetBandPIL (
         UINT8* dbuf,
         const UINT8* sbuf,
         int band,
         int outcols,
         int numbands,                          
         int InterleaveFactor,                  
         int numbits                            
         );

      static ERRVALUE ImportGeorefArcWorld (
         SIMPLE_ARRAY<CTRLPOINT3>& CtrlPoints,  
         const FILEPATH& filepath,              
         int rastlins,                          
         int rastcols                           
         );

      static ERRVALUE ImportGeorefMapInfoTAB (
         SIMPLE_ARRAY<CTRLPOINT3>& points,      
         SPATREF::COORDREFSYS& crs,             
         const FILEPATH& filepath               
         );

      INT32 GetHeaderBytes (
         ) const { return m_HeaderBytes; }
      
      INT32 GetLineHdrBytes (
         ) const { return m_LineHdrBytes; }

      INT32 GetLineTrailBytes (
         ) const { return m_LineTrailBytes; }

      INT32 GetBandHdrBytes (
         ) const { return m_BandHdrBytes; }

      INT32 GetBandNum (
         ) const { return m_BandNum; }

      INT32 GetBandTrailBytes (
         ) const { return m_BandTrailBytes; }

      INT32 GetInterleaveHdrBytes (
         ) const { return m_InterleaveHdrBytes; }

      INT32 GetInterleaveTrailBytes (
         ) const { return m_InterleaveTrailBytes; }

      INT32 GetNumCols (
         ) const { return m_NumCols; }

      INT32 GetNumLins (
         ) const { return m_NumLins; }

      INT32 GetNumBands (
         ) const { return m_NumBands; }

      INT32 GetNumBits (
         ) const { return m_NumBits; }

      RVC::IMAGE::CELLTYPE GetCellType (
         ) const { return m_CellType; }

      RVC::IMAGE::DATATYPE GetDataType (
         ) const { return m_DataType; }

      MIEINTERLEAVE GetInterleaveType (
         ) const { return m_InterleaveType; }

      INT32 GetInterleaveFactor (
         ) const { return m_InterleaveFactor; }

      BYTEORDER GetByteOrder (
         ) const { return m_ByteOrder; }

      INT32 GetLinePad (
         ) const { return  m_LinePad; }

      double GetNullValue (
         ) const { return m_NullValue; }

      FLIP GetFlip (
         ) const { return m_flip; }

      double GetScale (
         ) const { return m_scale; }

      double GetColScale (
         ) const { return m_ColScale; }

      double GetLinScale (
         ) const { return m_LinScale; }

      bool GetDoLink (
         ) const { return m_bDoLink; }       

      bool HasNull (
         ) const { return m_bHasNullValue; } 

      INT32 GetInitCol (
         ) const { return m_InitCol; }       

      INT32 GetInitLin (
         ) const { return m_InitLin; }       

      INT32 GetLastCol (
         ) const { return m_LastCol; }       

      INT32 GetLastLin (
         ) const { return m_LastLin; }       

      double GetDataScale (
         ) const { return m_DataScale;}         

      double GetDataOffset (
         ) const { return m_DataOffset;   }
      
      bool GetNoCheckSpace (
         ) const { return m_bNoCheckSpace; }

      ERRVALUE ImportGeneric (
         const FILEPATH& filepath
         ) { return v_ImportGeneric(filepath); }

      void SetHeaderBytes (
         INT32 value
         ) { m_HeaderBytes = value; }
      
      void SetLineHdrBytes (
         INT32 value
         ) { m_LineHdrBytes = value;   }

      void SetLineTrailBytes (
         INT32 value
         ) { m_LineTrailBytes = value; }

      void SetBandHdrBytes (
         INT32 value
         ) { m_BandHdrBytes = value;   }

      void SetBandNum (
         INT32 bandnum
         ) { m_BandNum = bandnum; }

      void SetBandTrailBytes (
         INT32 value
         ) { m_BandTrailBytes = value; }

      void SetInterleaveHdrBytes (
         INT32 value
         ) { m_InterleaveHdrBytes = value;   }

      void SetInterleaveTrailerBytes (
         INT32 value
         ) { m_InterleaveTrailBytes = value; }

      void SetNumCols (
         INT32 value
         ) { m_NumCols = value;  }

      void SetNumLins (
         INT32 value
         ) { m_NumLins = value;  }

      void SetNumBands (
         INT32 value
         ) { m_NumBands = value; }

      void SetNumBits (
         INT32 value
         );

      void SetCellType (
         RVC::IMAGE::CELLTYPE value
         ) {
         m_DataType = (RVC::IMAGE::GetDataTypeFromCellType(value));
         SetNumBits(RVC::IMAGE::GetNumBitsFromCellType(value));
         m_CellType = value;
         }

      void SetDataType (
         RVC::IMAGE::DATATYPE value
         );

      void SetInterleaveType (
         MIEINTERLEAVE value
         ) { m_InterleaveType = value; }

      void SetInterleaveFactor (
         INT32 value
         ) { m_InterleaveFactor = value; }

      void SetByteOrder (
         BYTEORDER value
         ) { m_ByteOrder = value; }

      void SetLinePad (
         INT32 value
         ) { m_LinePad = value; }

      void SetNullValue (
         double value
         ) { m_NullValue = value; m_bHasNullValue = true; }

      void SetFlip (
         FLIP value
         ) { m_flip = value; }

      void SetScale (
         double value
         ) { m_scale = value; }

      void SetColScale (
         double value
         ) { m_ColScale = value; }

      void SetLinScale (
         double value
         ) { m_LinScale = value; }

      void SetDoLink (
         bool value
         ) { m_bDoLink = value;   }       

      void SetHasNull (
         bool value
         ) { m_bHasNullValue = value; }   

      void SetInitCol (
         INT32 value
         ) { m_InitCol = value;  }        

      void SetInitLin (
         INT32 value
         ) { m_InitLin = value;  }        

      void SetLastCol (
         INT32 value
         ) { m_LastCol = value;  }        

      void SetLastLin (
         INT32 value
         ) { m_LastLin = value;  }        

      void SetDataScale (
         double value
         ) { m_DataScale = value;}        

      void SetDataOffset (
         double value
         ) { m_DataOffset = value;  }
      
      void SetNoCheckSpace (
         bool value
         ) { m_bNoCheckSpace = value; }

   protected:
      // The following methods are required to cascade, so must be protected

      virtual ERRVALUE v_ImportBegin (
         const RVC::OBJITEM& DestObj
         );

      virtual ERRVALUE v_ImportEnd (
         RVC::OBJITEM& DestObj
         );

   private:
      virtual ERRVALUE v_ImportGeneric (
         const FILEPATH& filepath
         ) = 0;

      INT32 m_HeaderBytes;          
      INT32 m_LineHdrBytes;            
      INT32 m_LineTrailBytes;          
      INT32 m_BandHdrBytes;            
      INT32 m_BandNum;                 
      INT32 m_BandTrailBytes;          
      INT32 m_InterleaveHdrBytes;         
      INT32 m_InterleaveTrailBytes;       
      INT32 m_NumCols;              
      INT32 m_NumLins;              
      INT32 m_NumBands;          
      INT32 m_NumBits;              
      RVC::IMAGE::DATATYPE m_DataType;          
      RVC::IMAGE::CELLTYPE m_CellType;
      MIEINTERLEAVE m_InterleaveType;  
      INT32 m_InterleaveFactor;              
      BYTEORDER m_ByteOrder;        
      INT32 m_LinePad;              
      FLIP m_flip;                  
      double m_scale;               
      double m_ColScale;
      double m_LinScale;
      bool m_bDoLink;            
      bool m_bHasNullValue;         
      INT32 m_InitCol;              
      INT32 m_InitLin;              
      INT32 m_LastCol;              
      INT32 m_LastLin;              
      double m_DataScale;           
      double m_DataOffset;       
      double m_NullValue;        
      bool m_bNoCheckSpace;         

   };

} // end of MIE NAMESPACE

#endif 

---