mie/settings.h

Go to the documentation of this file.

#ifndef INC_MIE_SETTINGS_H
#define INC_MIE_SETTINGS_H

#ifndef INC_MIE_MIE2_H
   #include <mie/mie2.h>
#endif

#ifndef INC_RVC_RASTER_H
   #include <rvc/raster.h>
#endif

#ifndef INC_RVC_VECTOR_H
   #include <rvc/vector.h>
#endif

#ifndef INC_MI32_TRANS2DMAPGEN_H
   #include <mi32/trans2dmapgen.h>
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
class XMLNODE;
class XMLDOC;
namespace SML {
   class CLASSMEMBER;
   }
namespace MIE {
   class FORMAT;
   }
#endif


namespace MIE {

// ************************************************************************
class SETTINGS {
   public:
      enum NULLCELLMODE {
         NULLCELL_FromSource,
         NULLCELL_Zero,
         NULLCELL_Min,
         NULLCELL_Max,
         NULLCELL_UserDefined
         };

      SETTINGS (
         const FORMAT& format,
         MODE mode,
         OBJTYPEFLAG ObjType = OBJTYPEFLAG_ALL
         );

      virtual ~SETTINGS();

      void ClearLinColRange (
         ) {
         m_bHasInitLin = m_bHasInitCol = m_bHasLastLin = m_bHasLastCol = false;
         }

      bool GetAssignLabelsToPolys (
         ) const { return m_bAssignLabelsToPolys; }

      bool GetByteOrderMSBFirst (
         ) const { return m_bByteOrderMSBFirst; }

      bool GetCanLink (
         ) const { return m_bCanLink; }

      bool GetCanChangeMultiSingle (
         ) const { return m_bCanChangeMultiSingle;}

      bool GetCanDoMultiLink (
         ) const { return m_bCanDoMultiLink; }

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

      CHAR_ENCODING GetCharEncoding (
         ) const { return m_CharEncoding; }

      double GetColScale (
         ) const { return m_ColScale; }

      const SPATREF::COORDREFSYS& GetCoordRefSys (
         ) const {
         return (m_crs);
         }

      bool GetCreateElementIDTables (
         ) const { return m_bCreateElementIDTables; }

      bool GetCreateStdAttribTables (
         ) const { return m_bCreateElementIDTables; }

      int GetCompressionLevel (
         ) const { return m_CompressionLevel; }

      RVC::RASTER::COMPTYPE GetCompressionType (
         ) const { return m_CompressionType; }

      RVC::IMAGE::CELLTYPE GetCellTypesAllowed (
         ) const { return m_CellTypesAllowed; }

      bool GetDoContrast (
         ) const { return m_bDoContrast; }

      bool GetDoHistogram (
         ) const { return m_bDoHistogram; }

      bool GetDoHypercube (
         ) const { return m_bDoHypercube; }

      bool GetDoMultiLink (
         ) const { return m_bDoMultiLink; }

      bool GetDoLink (
         ) const { return m_bDoLink; }

      bool GetLinkTables (
         ) const { return m_bLinkTables; }

      bool GetDoOptimize (
         ) const { return m_bDoOptimize; }

      bool GetDoSingleFile (
         ) const { return m_bDoSingleFile; }

      bool GetDoSurfaceProperties (
         ) const { return m_bDoSurfaceProperties; }

      const SPATREF::COORDREFSYS& GetExtentsCoordRefSys (
         ) const { return m_ExtentsCRS; }

      const TRANS2D_MAPGEN& GetExtentsTrans (
         ) const { return m_ExtentsTMG; }

      RVC::GEOMETRIC::ELEMSELECTPARMS::EXTRACT GetExtractRegionTest (
         ) const { return m_ExtractRegionTest; }

      bool GetFlipHorz (
         ) const { return m_bFlipHoriz; }

      bool GetFlipVert (
         ) const { return m_bFlipVert; }

      const FORMAT& GetFormat (
         ) const { return m_format; }

      INT32 GetInitCol (
         ) const { return m_InitCol; }

      INT32 GetInitLin (
         ) const { return m_InitLin; }

      bool GetInvertBW (
         ) const { return m_bInvertBW; }

      INT32 GetLastCol (
         ) const { return m_LastCol; }

      INT32 GetLastLin (
         ) const { return m_LastLin; }

      double GetLinScale (
         ) const { return m_LinScale; }

      MODE GetMode (
         ) const { return (m_mode); }

      double GetNullValue (
         ) const { return m_NullValue; }

      NULLCELLMODE GetNullExportMode (
         ) const { return m_NullMode; }

      int GetNumBands (
         ) const { return m_NumBands; }

      UINT32 GetNumCols (
         ) const { return m_NumCols; }

      UINT32 GetNumLins (
         ) const { return m_NumLins; }

      OBJTYPEFLAG GetObjTypeFlag (
         ) const;

      RVC::OBJTYPE GetObjType (
         ) const;

      bool GetOverrideCRS (
         ) const { return m_bOverrideCRS; }

      bool GetSaveProj (
         ) const { return m_bSaveProj; }

      GEOREFTYPE GetGeorefTypes (
         ) const { return m_GeorefTypes; }

      GEOREFTYPE GetGeorefTypeSelected (
         ) const { return m_GeorefTypeSelected; }

      RVC::IMAGE::PYRAMID GetPyramidFlags (
         ) const { return m_PyramidFlags; }

      ERRVALUE GetSchema (
         XMLNODE* ParentNode
         ) const { return v_GetSchema(ParentNode); }

      bool GetSeparateBands (
         ) const { return m_bSeperateBands; }

      RVC::VECTOR::TOPOLOGYTYPE GetTopologyType (
         ) const { return m_topologylevel; }

      bool GetUseNullValue (
         ) const { return m_bUseNullValue; }

      const DRECT3D& GetUserExtents (
         ) const { return m_UserExtents; }

      ERRVALUE GetValues (
         XMLNODE* ParentNode
         ) const { return v_GetValues(ParentNode); }

      double GetXShift (
         ) const { return (m_xshift); }

      double GetYShift (
         ) const { return (m_yshift); }

      int GetZUnits (
         ) const { return (m_zunits); }


      bool HasByteOrder (
         ) const { return m_bHasByteOrder; }

      bool HasCellSize (
         ) const { return m_bHasCellSize; }

      bool HasCRS (
         ) const {
         return (m_crs.IsDefined());
         }

      bool HasCellType (
         ) const { return m_bHasCellType; }

      bool HasInitCol (
         ) const { return m_bHasInitCol; }

      bool HasInitLin (
         ) const { return m_bHasInitLin; }

      bool HasLastCol (
         ) const { return m_bHasLastCol; }

      bool HasLastLin (
         ) const { return m_bHasLastLin; }


      bool HasLinCol (
         ) const { return m_bHasLinCol; }

      bool HasNonRandomAccessTables (
         ) const { return m_bHadNonRandomAccessTables; }

      bool HasNullValue (
         ) const { return m_bHasNullValue; }

      bool HasNumBands (
         ) const { return m_bHasNumBands; }

      bool HasValidExtents (
         ) const { return m_bHasValidExtents; }

      bool Is3D (
         ) const { return m_bIs3D; }

      bool IsSafeToExport (
         ) const;

      bool IsSafeToImport (
         ) const;

      ERRVALUE ReadParmsIni (
         );

      void SetAssignLabelsToPolys (
         bool AssignLabelsToPolys
         ) { m_bAssignLabelsToPolys = AssignLabelsToPolys; }

      void SetByteOrderMSBFirst (
         bool value,
         bool bHasValue = true
         ) {
         m_bByteOrderMSBFirst = value;
         m_bHasByteOrder = bHasValue;
         }

      void SetCanChangeMultiSingle (
         bool value = true
         ) { m_bCanChangeMultiSingle = value;}

      void SetCanDoMultiLink (
         bool value = true
         ) { m_bCanDoMultiLink = value; }

      void SetCanLink (
         bool value = true
         ) { m_bCanLink = value; }

      void SetCellSize (
         double linscale,
         double colscale,
         bool bHasValue = true
         ) {
         m_LinScale = linscale;
         m_ColScale = colscale;
         m_bHasCellSize = bHasValue;
         }

      void SetCellType (
         RVC::IMAGE::CELLTYPE  celltype,
         bool bHasValue = true
         ) {
         m_CellType = celltype;
         m_bHasCellType = bHasValue;
         }

      void SetCharEncoding (
         CHAR_ENCODING value
         ) { m_CharEncoding = value; }

      void SetCompressionLevel (
         int value
         ) { m_CompressionLevel = value; }

      void SetCompressionType (
         RVC::RASTER::COMPTYPE type
         ) { m_CompressionType = type; }

      void SetCoordRefSys (
         const SPATREF::COORDREFSYS& crs
         );

      void SetCreateElementIDTables (
         bool val = true
         ) { m_bCreateElementIDTables = val; }

      void SetCreateStdAttribTables (
         bool val = true
         ) { m_bCreateElementIDTables = val; }


      void SetCellTypesAllowed (
         RVC::IMAGE::CELLTYPE value
         ) {
         m_CellTypesAllowed = value;
         }

      void SetDoContrast (
         bool val = false
         ) { m_bDoContrast = val; }

      void SetDoHistogram (
         bool val = true
         ) { m_bDoHistogram = val; }

      void SetDoHypercube (
         bool val = true
         ) { m_bDoHypercube = val; }

      void SetDoMultiLink (
         bool val = true
         ) { m_bDoMultiLink = val; }

      void SetDoLink (
         bool val = true
         ) { m_bDoLink = val; }

      void SetLinkTables (
         bool val = true
         ) { m_bLinkTables = val; }

      void SetDoOptimize (
         bool val = true
         ) { m_bDoOptimize = val; }

      void SetDoSingleFile (
         bool val = true
         ) { m_bDoSingleFile = val;}

      void SetDoSurfaceProperties (
         bool DoSurface = true
         ) { m_bDoSurfaceProperties = DoSurface; }

      void SetExtentsCoordRefSys (
         const SPATREF::COORDREFSYS& crs
         );

      void SetExtractRegionTest (
         RVC::GEOMETRIC::ELEMSELECTPARMS::EXTRACT val
         ) { m_ExtractRegionTest = val; }

      void SetFlipHorz (
         bool value
         ) { m_bFlipHoriz = value; }

      void SetFlipVert (
         bool value
         ) { m_bFlipVert = value; }

      void SetHasLinCol (
         bool value = true
         ) { m_bHasLinCol = value; }

      void SetHasNonRandomAccessTables (
         bool value = true
         ) { m_bHadNonRandomAccessTables = value; }

      void SetInitCol (
         INT32 value,
         bool bHasValue = true
         ) {
         m_InitCol = value;
         m_bHasInitCol = bHasValue;
         }

      void SetInitLin (
         INT32 value,
         bool bHasValue = true
         ) {
         m_InitLin = value;
         m_bHasInitLin = bHasValue;
         }

      void SetInvertBW (
         bool value
         ) { m_bInvertBW = value; }

      void SetIs3D (
         bool val
         ) { m_bIs3D = val; }

      void SetLastCol (
         INT32 value,
         bool bHasValue = true
         ) {
         m_LastCol = value;
         m_bHasLastCol = bHasValue;
         }

      void SetLastLin (
         INT32 value,
         bool bHasValue = true
         ) {
         m_LastLin = value;
         m_bHasLastLin = bHasValue;
         }

      void SetNullExportMode (
         NULLCELLMODE mode
         );

      void SetMode (
         MODE mode
         ) { m_mode = mode; }

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

      void SetNumBands (
         int value,
         bool bHasValue = true
         ) {
         m_bHasNumBands = bHasValue;
         m_NumBands = value;
         }

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

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

      void SetOverrideCRS (
         bool value
         ) { m_bOverrideCRS = value; }

      void SetObjTypeSelected (
         OBJTYPEFLAG types
         );

      void SetObjTypeSelected (
         RVC::OBJTYPE type
         );

      void SetPyramidFlags (
         RVC::IMAGE::PYRAMID PyramidFlags
         ) { m_PyramidFlags = PyramidFlags; }

      void SetSaveProj (
         bool value = true
         ) { m_bSaveProj = value; }

      void SetGeorefTypes (
         GEOREFTYPE types
         ) { m_GeorefTypes = types; }

      void SetGeorefTypeSelected (
         GEOREFTYPE type
         ) { m_GeorefTypeSelected = type; }

      void SetSeparateBands (
         bool value
         ) { m_bSeperateBands = value; }

      void SetTopologyType (
         RVC::VECTOR::TOPOLOGYTYPE type
         ) { m_topologylevel = type; }

      void SetUseNullValue (
         bool value
         ) { m_bUseNullValue = value; }

      void SetUserExtents (
         const DRECT3D& rect,
         bool bValid
         );

      ERRVALUE SetValues (
         const XMLNODE* ParentNode
         ) { return v_SetValues(ParentNode); }

      void SetXShift (
         double val
         ) { m_xshift = val; }

      void SetYShift (
         double val
         ) { m_yshift = val; }

      void SetZUnits (
         int val
         ) { m_zunits = val; }

      ERRVALUE SMLValidateExportSettings (
         const RVC::OBJITEM& ObjItem      
         ) { return v_SMLValidateExportSettings(ObjItem); }

      ERRVALUE SMLValidateImportSettings (
         ) { return v_SMLValidateImportSettings(); }

      ERRVALUE WriteParmsIni (
         ) const;


   private:
      const FORMAT& m_format;
      MODE m_mode;
      OBJTYPEFLAG m_ObjTypeSelected;      
      RVC::OBJTYPE m_objtype;             
      double m_xshift;
      double m_yshift;
      int m_zunits;
      bool m_bSaveProj;
      bool m_bHasValidExtents;         
      DRECT3D m_UserExtents;           
      bool m_bCanLink;                 
      bool m_bDoContrast;              
      bool m_bDoHistogram;             
      bool m_bDoLink;                  
      bool m_bDoMultiLink;             
      bool m_bDoHypercube;             
      bool m_bLinkTables;              
      RVC::IMAGE::PYRAMID m_PyramidFlags; 
      GEOREFTYPE m_GeorefTypeSelected;    
      GEOREFTYPE m_GeorefTypes;           
      bool m_bIs3D;                       
      TRANS2D_MAPGEN m_ExtentsTMG;              
      RVC::GEOMETRIC::ELEMSELECTPARMS::EXTRACT m_ExtractRegionTest;        
      SPATREF::COORDREFSYS m_ExtentsCRS;  

      RVC::VECTOR::TOPOLOGYTYPE m_topologylevel;               
      bool m_bDoOptimize;                 
      bool m_bCreateElementIDTables;         
      bool m_bCreateStdAttribTables;         

      bool m_bSeperateBands;
      int m_NumBands;
      bool m_bByteOrderMSBFirst;
      bool m_bFlipVert;
      bool m_bFlipHoriz;
      bool m_bInvertBW;
      bool m_bOverrideCRS;                

      RVC::RASTER::COMPTYPE m_CompressionType;
      int m_CompressionLevel;
      bool m_bUseNullValue;
      RVC::IMAGE::CELLTYPE m_CellTypesAllowed;  // CELLTYPE values that are valid for this raster (a bunch of bits logical ORd together)
      INT32 m_InitCol;
      INT32 m_InitLin;
      INT32 m_LastCol;
      INT32 m_LastLin;
      double m_NullValue;
      UINT32 m_NumLins;
      UINT32 m_NumCols;
      double m_LinScale;
      double m_ColScale;
      bool m_bHasInitLin;
      bool m_bHasInitCol;
      bool m_bHasLastLin;
      bool m_bHasLastCol;

      bool m_bHasNumBands;
      bool m_bHasLinCol;
      bool m_bHasCellType;
      bool m_bHasCellSize;
      bool m_bHasNullValue;
      bool m_bHasByteOrder;
      RVC::IMAGE::CELLTYPE  m_CellType; // A single bit out of m_CellTypesAllowed
      CHAR_ENCODING m_CharEncoding;
      SPATREF::COORDREFSYS m_crs;      
      bool m_bDoSingleFile;               
      bool m_bCanChangeMultiSingle;          
      bool m_bCanDoMultiLink;
      bool m_bHadNonRandomAccessTables;
      bool m_bAssignLabelsToPolys;
      NULLCELLMODE m_NullMode;
      bool m_bDoSurfaceProperties;

   protected:

      static XMLNODE* AddValueNode (
         XMLNODE *ParentNode,
         const char *name,
         const MISTRING& value
         );

      static bool FindValueNode (
         const XMLNODE *ParentNode, 
         const char *name,          
         MISTRING &value            
         );

      static bool FindValueNode (
         const XMLNODE *ParentNode, 
         const char *name,          
         bool &value                
         );

      static bool FindValueNode (
         const XMLNODE *ParentNode, 
         const char *name,          
         INT32 &value               
         );

      static bool FindValueNode (
         const XMLNODE *ParentNode, 
         const char *name,          
         UINT32 &value              
         );

      static bool FindValueNode (
         const XMLNODE *ParentNode, 
         const char *name,          
         double &value              
         );

      virtual ERRVALUE v_GetSchema (
         XMLNODE* ParentNode
         ) const;

      virtual ERRVALUE v_GetValues (
         XMLNODE* ParentNode
         ) const;

      virtual ERRVALUE v_SetValues (
         const XMLNODE* ParentNode
         );

   private:

      static const XMLNODE* SETTINGS::FindChildValueNode (
         const XMLNODE *ParentNode,
         const char *name
         );

      virtual ERRVALUE v_AnalyzeObjects (
         const RVC::OBJITEMLIST& objects
         );

      virtual ERRVALUE v_AnalyzeSource (
         const MISTRING& source
         );

      virtual ERRVALUE v_AnalyzeFile (
         const FILEPATH& source
         );

      virtual void v_OnChangeCRS (
         ) {}


      virtual bool v_IsSafeToExport (
         ) const;


      virtual bool v_IsSafeToImport (
         ) const;

      virtual ERRVALUE v_ReadParmsIni();

      virtual ERRVALUE v_WriteParmsIni() const;

      virtual ERRVALUE v_SMLValidateExportSettings (
         const RVC::OBJITEM& ObjItem      
         );

      virtual ERRVALUE v_SMLValidateImportSettings (
         );

      ERRVALUE IniReadLow (
         SML::CLASSMEMBER*,
         const char* key
         );

      ERRVALUE IniWriteLow (
         SML::CLASSMEMBER*,
         const char* key
         ) const;

      friend class FORMAT;    // Only want FORMAT to be able to call some thing

      friend class SML_MIEHANDLE;
      friend class SML_MIERASTER;
      friend class SML_MIEVECTOR;
      friend class SML_MIECAD;
      friend class SML_MIETIN;
      friend class SML_MIEDATABASE;
   };

}  // End namespace MIE

#endif 

---