rvc/geospatl.h

Go to the documentation of this file.

#ifndef INC_RVC_GEOSPATL_H
#define INC_RVC_GEOSPATL_H

#ifndef INC_RVC_OBJECT_H
   #include <rvc/object.h>
#endif

#ifndef INC_RVC_GETOBJFILTER_H
   #include <rvc/getobjfilter.h>
#endif

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

#ifndef INC_MI32_RECT_H
   #include <mi32/rect.h>
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward declarations
class REGION2D;
namespace RVC {
   class GEOREFERENCE;
   }
#endif


namespace RVC {

class GEOSPATIAL : public RVC::OBJECT {
   public:
   
      #ifndef GENERATING_DOXYGEN_OUTPUT
      class GETOBJFILTER_ISSELECTABLE;
      class GETOBJFILTER_ISOVERLAPPING;
      class GETOBJFILTER_HASGEOREFERENCE;
      class GETOBJFILTER_HASNOGEOREFERENCE;
      class GETOBJFILTER_HASNONLOCALGEOREFERENCE;
      #endif // GENERATING_DOXYGEN_OUTPUT
      
      enum CAPABILITY {
         CAPABILITY_None =         0,
         CAPABILITY_RandomAccess = 256,      
         CAPABILITY_CanBeModified,           
         CAPABILITY_LoginRequired,           
         CAPABILITY_PreferKeepOpen,          
         CAPABILITY_CanGenerateRegion,       
         CAPABILITY_NeedScanAutoLink,        
         CAPABILITY_ScanDoesGenerateRegion,  
         CAPABILITY_ScanDoesBuildIndex,      
         };
         
      enum MAKELINKFLAGS {
         MAKELINKFLAG_None =              0x0000,
         MAKELINKFLAG_NoGeoreference =    0x0001,  
         MAKELINKFLAG_NoPyramidLinks =    0x0002,  
         MAKELINKFLAG_BuildHistograms =   0x0004,  
         MAKELINKFLAG_BuildPyramids =     0x0008,  
         MAKELINKFLAG_NoContrastTables =  0x0010,  
         MAKELINKFLAG_ColorComposite =    0x0020,  
         MAKELINKFLAG_ColorSeparate =     0x0040   
         };
         
      enum OBJECTREGIONFLAGS {
         OBJECTREGION_Default =           0x0000,
         OBJECTREGION_UseGeorefModel =    0x0001,  
         OBJECTREGION_ForceArbitrary =    0x0002   
         };

      static RVC::GEOSPATIAL* GetGeospatial (
         const RVC::OBJECT& obj              
         );

      static RVC::GEOSPATIAL* GetGeospatial (
         const RVC::OBJITEM& ObjItem         
         );

      static RVC::OBJTYPESET GetObjTypeSet (
         );
         
      static bool IsGeospatial (
         RVC::OBJTYPE ObjType
         );

      GEOSPATIAL (
         );

      GEOSPATIAL (
         const RVC::GEOSPATIAL& rhs
         );

      virtual ~GEOSPATIAL (
         ) = 0;

      ERRVALUE CheckGeorefName (
         RVC::OBJECTNAME& GeorefName         
         );

      INT32 ComputeObjectScale (
         RVC::GEOREFERENCE& ObjGeoref,       
         double& xscale,                     
         double& yscale,                     
         bool ConvertToMeters                
         ) const;

      ERRVALUE ComputeObjectTranslation (
         const RVC::GEOSPATIAL& ObjTarget,
         TRANS2D_MAPGEN& SrcToDest
         );

      ERRVALUE ComputeScaleFromGeoref (
         const RVC::GEOREFERENCE& DftGeoref, 
         double& xscale,                     
         double& yscale,                     
         bool ConvertToMeters                
         ) const;

      ERRVALUE CopyGeorefTo (
         const RVC::GEOSPATIAL& DestObj
         );

      ERRVALUE CopyGeorefTo (
         const RVC::GEOSPATIAL& DestObj,
         const TRANS2D_AFFINE& SrcToDest
         );

      ERRVALUE CopyGeorefTo (
         const RVC::GEOSPATIAL& DestObj,
         const TRANS2D_MAPGEN& SrcToDest
         );

      bool HasCapability (
         int Capability                      
         ) const;
         
      int GetDefaultGeoref (
         RVC::GEOREFERENCE& GeorefObj        
         ) const;
         
      void GetExtents (
         DRECT3D& extents                    
         ) const { v_GetExtents(extents); }

      ERRVALUE GetObjectMapRegion (
         RVC::GEOREFERENCE& GeorefObj,       
         REGION2D& region,                   
         OBJECTREGIONFLAGS flags = OBJECTREGION_Default
         ) const;

      ERRVALUE GetObjectRegion (
         RVC::GEOREFERENCE& GeorefObj,       
         REGION2D& region,                   
         TRANS2D_MAPGEN& ObjectToMap,        
         OBJECTREGIONFLAGS flags = OBJECTREGION_Default
         ) const;

      void GetScale (
         double& xscale,                     
         double& yscale                      
         ) const { v_GetScale(xscale, yscale); }

      double GetZOffset (
         ) const { return (v_GetZOffset()); }
         
      double GetZScale (
         ) const { return (v_GetZScale()); }

      ERRVALUE ScanAutoLink (
         ) { return (v_ScanAutoLink()); }

      ERRVALUE SetObjectScale (
         double xscale,                      
         double yscale,                      
         bool onlyifzero                     
         );

      ERRVALUE SetScaleFromGeoref (
         RVC::GEOREFERENCE& GeorefObj,
         bool onlyifzero
         );

      void SetZOffset (
         double zoffset
         ) { v_SetZOffset(zoffset); }
         
      void SetZScale (
         double zscale
         ) { v_SetZScale(zscale); }
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual void v_GetExtents (DRECT3D& extents) const = 0;
      virtual void v_GetScale (double& xscale, double& yscale) const = 0;
      virtual double v_GetZScale () const = 0;
      virtual double v_GetZOffset () const = 0;
      virtual bool v_HasCapability (int Capability) const = 0;
      virtual ERRVALUE v_ScanAutoLink ();
      virtual void v_SetZScale (double zscale) = 0;
      virtual void v_SetZOffset (double zoffset) = 0;
      virtual void v_SetScale (double xscale, double yscale) = 0;
      #endif // GENERATING_DOXYGEN_OUTPUT

   };

#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(GEOSPATIAL::MAKELINKFLAGS)
DEFINE_ENUM_OP_BITWISE(GEOSPATIAL::OBJECTREGIONFLAGS)
#endif

class GEOSPATIAL::GETOBJFILTER_ISSELECTABLE : public GETOBJFILTER {
   public:
      GETOBJFILTER_ISSELECTABLE () {}
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual bool v_IsSelectable (const RVC::OBJITEM& ObjItem, int position);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
   
class GEOSPATIAL::GETOBJFILTER_ISOVERLAPPING : public GETOBJFILTER {
   public:
      // Constructor.
      GETOBJFILTER_ISOVERLAPPING (
         const RVC::OBJITEM& ObjItemRef
         );
         
      virtual ~GETOBJFILTER_ISOVERLAPPING () {}

      void SetObjItemRef (
         const RVC::OBJITEM& ObjItemRef
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      OBJITEM m_ObjItemRef;
      TRANS2D_MAPGEN m_RefToSelected;
      DRECT3D m_RefExtents;
      bool m_RefHasLocalCRS;
      
      virtual bool v_IsSelectable (const RVC::OBJITEM& ObjItem, int position);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
   
class GEOSPATIAL::GETOBJFILTER_HASGEOREFERENCE : public GETOBJFILTER {
   public:
      GETOBJFILTER_HASGEOREFERENCE () {}
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual bool v_IsSelectable (const RVC::OBJITEM& ObjItem, int position);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
   
class GEOSPATIAL::GETOBJFILTER_HASNONLOCALGEOREFERENCE : public GETOBJFILTER {
   public:
      GETOBJFILTER_HASNONLOCALGEOREFERENCE () {}
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual bool v_IsSelectable (const RVC::OBJITEM& ObjItem, int position);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
   
class GEOSPATIAL::GETOBJFILTER_HASNOGEOREFERENCE : public GETOBJFILTER {
   public:
      GETOBJFILTER_HASNOGEOREFERENCE () {}
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual bool v_IsSelectable (const RVC::OBJITEM& ObjItem, int position);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
   
}     

#endif      

---