rvc/opbufferzone.h

Go to the documentation of this file.

#ifndef  INC_RVC_OPBUFFERZONE_H
#define  INC_RVC_OPBUFFERZONE_H

#ifndef  INC_MI32_LATLONFM_H
#include <mi32/latlonfm.h>
#endif

#ifndef INC_MI32_SPATREF_H
#include <mi32/spatref.h>
#endif

#ifndef  INC_MI32_BITSET_H
#include <mi32/bitset.h>
#endif

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

#ifndef  INC_MI32_DOUBLEAR_H
#include <mi32/doublear.h>
#endif

#ifndef  INC_RVC_OBJECTNAME_H
#include <rvc/objectname.h>
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT
class AUTOCOLORGEN;
class MISTRING;
#endif // GENERATING_DOXYGEN_OUTPUT

namespace RVC {

#ifndef GENERATING_DOXYGEN_OUTPUT
class DBASE_ELEMENT;
class OBJITEM;
class OBJITEMLIST;
#endif // GENERATING_DOXYGEN_OUTPUT

namespace OP {

class BUFFERZONE {
public:

   enum SOURCE {
      SOURCE_Vector = 0,
      SOURCE_CAD = 1,
      SOURCE_Shape = 2,
      SOURCE_Table = 3,
      SOURCE_Region = 4,
      SOURCE_Count = 5
      };

   enum PROCESS {
      PROCESS_None     = 0,
      PROCESS_All      = 1,
      PROCESS_Selected = 2,
      PROCESS_ByQuery = 3
      };

   enum DISTANCE {
      DISTANCE_AllSame = 0,
      DISTANCE_ByScript = 1
      };

   enum SEPARATE {
      SEPARATE_None = 0,
      SEPARATE_ByAttribute = 1,
      SEPARATE_ByElement = 2
      };

   enum TYPE {
      TYPE_Single = 0,
      TYPE_MultipleEqual = 1,
      TYPE_MultipleUnequal = 2
      };

   enum DIRECTION {
      DIRECTION_Outside = 0,
      DIRECTION_Inside = 1
      };

   enum METHOD {
      METHOD_Approximate = 0,
      METHOD_Accurate = 1
      };

   class ELEMENT {
   public:

      ELEMENT (
         );

      ~ELEMENT (
         ) {}

      ELEMENT (
         const ELEMENT& rhs
         );

      ELEMENT& operator= (
         const ELEMENT& rhs
         );

      void Clear (
         );

      PROCESS GetProcess (
         ) const;

      const BITSET& GetBitset (
         ) const;

      DISTANCE GetDistance (
         ) const;

      const MISTRING& GetDistanceScript (
         ) const;

      const MISTRING& GetProcessQuery (
         ) const;

      void GetSeparateAttribute (
         MISTRING& table,
         MISTRING& field
         ) const;

      SEPARATE GetSeparate (
         ) const;

      bool GetTransferAttributes (
         ) const;

      void SetProcess (
         const PROCESS process
         );

      void SetBitset (
         const BITSET& bitset
         );

      void SetDistance (
         const DISTANCE distance
         );

      void SetDistanceScript (
         const MISTRING& script
         );

      void SetProcessQuery (
         const MISTRING& query
         );

      void SetSeparate (
         const SEPARATE separate
         );

      void SetSeparateAttribute (
         const MISTRING& table,
         const MISTRING& field
         );

      void SetTransferAttributes (
         const bool transfer
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      PROCESS m_Process;
      MISTRING m_ProcessQuery;
      DISTANCE m_Distance;
      BITSET m_Bitset;
      MISTRING m_DistanceScript;
      SEPARATE m_Separate;
      bool m_TransferAttributes;
      MISTRING m_TableName;
      MISTRING m_FieldName;
      #endif // GENERATING_DOXYGEN_OUTPUT
      };

   class SOURCE_PARAMETERS {
   public:

      SOURCE_PARAMETERS (
         const SOURCE source
         );

      virtual ~SOURCE_PARAMETERS (
         ) {}

      SOURCE GetSource (
         ) const { return m_Source; }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      SOURCE_PARAMETERS (
         );

      const SOURCE m_Source;
      #endif // GENERATING_DOXYGEN_OUTPUT
      };

   class VECTOR_PARAMETERS : public SOURCE_PARAMETERS {
   public:

      enum TYPE {
         TYPE_Point = 0,
         TYPE_Line = 1,
         TYPE_Polygon = 2
         };

      VECTOR_PARAMETERS (
         );

      ~VECTOR_PARAMETERS (
         ) {}

      VECTOR_PARAMETERS& operator= (
         const VECTOR_PARAMETERS& 
         );

      const ELEMENT& GetElement (
         const TYPE type
         ) const;

      void SetElement (
         const TYPE type,
         const ELEMENT& element
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      ELEMENT m_Point;
      ELEMENT m_Line;
      ELEMENT m_Polygon;
      #endif // GENERATING_DOXYGEN_OUTPUT
      };

   class CAD_PARAMETERS : public SOURCE_PARAMETERS {
   public:

      CAD_PARAMETERS (
         );

      ~CAD_PARAMETERS (
         ) {}

      CAD_PARAMETERS& operator= (
         const CAD_PARAMETERS& 
         );

      const ELEMENT& GetElement (
         ) const;

      void SetElement (
         const ELEMENT& element
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      ELEMENT m_Element;
      #endif // GENERATING_DOXYGEN_OUTPUT
      };

   class SHAPE_PARAMETERS : public SOURCE_PARAMETERS {
   public:

      SHAPE_PARAMETERS (
         );

      ~SHAPE_PARAMETERS (
         ) {}

      SHAPE_PARAMETERS& operator= (
         const SHAPE_PARAMETERS& 
         );

      const ELEMENT& GetElement (
         ) const;

      void SetElement (
         const ELEMENT& element
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      ELEMENT m_Element;
      #endif // GENERATING_DOXYGEN_OUTPUT
      };

   class REGION_PARAMETERS : public SOURCE_PARAMETERS {
   public:

      REGION_PARAMETERS (
         );

      ~REGION_PARAMETERS (
         ) {}

      REGION_PARAMETERS& operator= (
         const REGION_PARAMETERS& 
         );

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

   class TABLE_PARAMETERS : public SOURCE_PARAMETERS {
   public:

      enum NAME {
         NAME_XField = 0,
         NAME_YField = 1,
         NAME_Count = 2
         };

      TABLE_PARAMETERS (
         );

      ~TABLE_PARAMETERS (
         ) {}

      TABLE_PARAMETERS& operator= (
         const TABLE_PARAMETERS& 
         );

      const SPATREF::COORDREFSYS& GetCoordRefSys (
         ) const;

      const ELEMENT& GetElement (
         ) const;

      const DRECT3D& GetExtents (
         ) const;

      const DMSTYPE GetLatLonFormat (
         ) const;

      const RVC::OBJECTNAME& GetName (
         const NAME id
         ) const;

      const MISTRING& GetQuery (
         ) const;

      UINT8 GetXUnitCode (
         ) const;

      UINT8 GetYUnitCode (
         ) const;

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

      void SetElement (
         const ELEMENT& element
         );

      void SetExtents (
         const DRECT3D& extents
         );

      void SetLatLonFormat (
         const DMSTYPE format
         );

      void SetName (
         const NAME id,
         const RVC::OBJECTNAME& name
         );

      void SetQuery (
         const MISTRING& query
         );

      void SetXUnitCode (
         const UINT8 unitcode
         );

      void SetYUnitCode (
         const UINT8 unitcode
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      ELEMENT m_Pin;
      RVC::OBJECTNAME m_Names[NAME_Count];
      SPATREF::COORDREFSYS m_CoordRefSys;
      DRECT3D m_Extents;
      MISTRING m_Query;
      DMSTYPE m_LatLonFormat;
      UINT8 m_XUnitCode;
      UINT8 m_YUnitCode;
      #endif // GENERATING_DOXYGEN_OUTPUT
      };

   class PARAMETERS {
   public:

      PARAMETERS (
         );

      ~PARAMETERS (
         ) {}

      void Clear ();

      int GetDistanceUnit (
         ) const;

      DIRECTION GetDirection (
         ) const;

      double GetDistance (
         ) const;

      double GetStartingDistance (
         ) const;

      double GetEndingDistance (
         ) const;

      double GetInterval (
         ) const;

      METHOD GetMethod (
         ) const;

      const DOUBLE_ARRAY<double>& GetDistances (
         ) const;

      TYPE GetType (
         ) const;

      bool GetSaveInSingleObject (
         ) const;

      bool GetUsePolygonsAsRegion (
         ) const;

      void SetDirection (
         const DIRECTION direction
         );

      void SetDistanceUnit (
         const int unit
         );

      void SetDistance (
         const double distance
         );

      void SetStartingDistance (
         const double distance
         );

      void SetEndingDistance (
         const double distance
         );

      void SetInterval (
         const double interval
         );

      void SetMethod (
         const METHOD method
         );

      void SetDistances (
         const DOUBLE_ARRAY<double>& distances
         );

      void SetType (
         const TYPE type
         );

      void SetSaveInSingleObject (
         const bool save
         );

      void SetUsePolygonsAsRegion (
         const bool use
         );

   private:

#ifndef GENERATING_DOXYGEN_OUTPUT

      TYPE m_Type;
      double m_Distance;
      double m_StartingDistance;
      double m_EndingDistance;
      double m_Interval;
      DOUBLE_ARRAY<double> m_Distances;
      bool m_SaveInSingleObject;
      DIRECTION m_Direction;
      METHOD m_Method;
      bool m_UsePolygonsAsRegion;
      int m_DistanceUnit;

#endif // GENERATING_DOXYGEN_OUTPUT

      };

   static ERRVALUE Process (
      const RVC::OBJITEM& SrcObjItem,
      RVC::OBJITEM& DestObjItem, 
      const SOURCE_PARAMETERS* SourceParameters,
      const PARAMETERS& Parameters 
      );

private:

   static ERRVALUE ProcessSingle (
      const RVC::OBJITEM& SrcObjItem,
      RVC::OBJITEM& DestObjItem, 
      const SOURCE_PARAMETERS* SourceParameters,
      const PARAMETERS& Parameters,
      AUTOCOLORGEN& autocolor
      );

   static ERRVALUE ProcessMultiple (
      const RVC::OBJITEM& SrcObjItem,
      RVC::OBJITEM& DestObjItem, 
      const SOURCE_PARAMETERS* SourceParameters,
      const PARAMETERS& Parameters,
      AUTOCOLORGEN& autocolor
      );

   static ERRVALUE AddBufferDistanceTable (
      const RVC::OBJITEM& objitem,
      const double prev,
      const double distance,
      const double next
      );

   static ERRVALUE MakeVectorBufferTable (
      RVC::DBASE_ELEMENT& database,
      const BITSET& bitset,
      const double prev,
      const double distance,
      const double next
      );

   static ERRVALUE MakeCADBufferTable (
      RVC::DBASE_ELEMENT& database,
      const INT32 numElements,
      const double distance
      );

   static ERRVALUE CopyMultiple (
      const RVC::OBJITEM& SrcObjItem,
      RVC::OBJITEM& DestObjItem,
      const PARAMETERS& parameters,
      const RVC::OBJITEMLIST& objitems
      );

   static ERRVALUE CopyVectorMultiple (
      const RVC::OBJITEM& SrcObjItem,
      RVC::OBJITEM& DestObjItem,
      const PARAMETERS& parameters,
      const RVC::OBJITEMLIST& objitems
      );

   static ERRVALUE CopyCADMultiple (
      const RVC::OBJITEM& SrcObjItem,
      RVC::OBJITEM& DestObjItem,
      const PARAMETERS& parameters,
      const RVC::OBJITEMLIST& objitems
      );

   static ERRVALUE CopyRegionMultiple (
      const RVC::OBJITEM& SrcObjItem,
      RVC::OBJITEM& DestObjItem,
      const PARAMETERS& parameters,
      const RVC::OBJITEMLIST& objitems
      );
   
};

}  // end namespace OP
}  // end namespace RVC


#endif  // INC_RVC_OPBUFFERZONE_H

---