rvc/mstdatt.h

Go to the documentation of this file.

#ifndef  INC_RVC_MSTDATT_H
#define  INC_RVC_MSTDATT_H

#ifndef  INC_MI32_TRANS2DC_H
   #include <mi32/trans2dc.h>
#endif

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

#ifndef  INC_RVC_CAD_H
   #include <rvc/cad.h>
#endif

#ifndef  INC_RVC_TIN_H
   #include <rvc/tin.h>
#endif

#ifndef  INC_RVC_DBLINE_H
   #include <rvc/dbline.h>
#endif

#ifndef  INC_RVC_DBPOLY_H
   #include <rvc/dbpoly.h>
#endif

#ifndef  INC_RVC_DBCAD_H
   #include <rvc/dbcad.h>
#endif

#ifndef  INC_RVC_DBTEDGE_H
   #include <rvc/dbtedge.h>
#endif

#ifndef  INC_RVC_DBTTRI_H
   #include <rvc/dbttri.h>
#endif


struct MSTATDATA;
namespace UOM {
   class UNIT;
   }

namespace RVC {

class MSTDATT {
   public:

      // ENUMERATIONS
      enum ADDSTAT {
         ADDSTAT_None = 0,
         ADDSTAT_MaxDim = 1,
         ADDSTAT_PointInPoly = 2,
         ADDSTAT_ZAttrib = 4
         };
         
      enum TABLEFLAG {
         TABLEFLAG_None = 0,
         TABLEFLAG_OnlyIfExisting = 1,
         TABLEFLAG_UseExistingFields = 2
         };
         
      struct ATTDEF;
      class COMPSTAT {
         public:
            
            COMPSTAT (
               );
         
            ~COMPSTAT (
               ) {};
         
            double Get2DDistance (
               const DPOINT2D& pt1,
               const DPOINT2D& pt2
               ) const;
            
            double Get3DDistance (
               const DPOINT3D& pt1,
               const DPOINT3D& pt2
               ) const;
            
            double GetAreaScaled (
               const DPOINT2D& point1,
               double area
               ) const;
            
            void GetEdgeStats (
               DPOINT3D& pt1,
               DPOINT3D& pt2,
               MSTATDATA& StatValues
               ) const;

            double GetEdgeSlopeStat (
               DPOINT3D& pt1,
               DPOINT3D& pt2,
               DPOINT3D& pt3
               ) const;

            ERRVALUE GetLineStats (
               const POLYLINE& PolyLine,
               MSTATDATA& StatValues
               ) const;    
         
            ERRVALUE GetPolygonArea (
               const POLYLINE& PolyLine,
               MSTATDATA& StatValues,
               bool ConvertToSqMeters
               ) const;
               
            const TRANS2D_MAPGEN& GetTransparm (
               ) const { return (m_tmg); }

            void GetTriangleStats (
               DPOINT3D& Node1,
               DPOINT3D& Node2,
               DPOINT3D& Node3,
               MSTATDATA& StatValues
               ) const;

            bool GetUnitArea (
               UOM::UNIT& AreaUnit
               ) const;
               
            const UOM::UNIT& GetUnitLength (
               ) const;
               
            double GetXScale (
               ) const { return (m_XScale); }

            double GetYScale (
               ) const { return (m_YScale); }

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

            void SetTransparm (
               const TRANS2D_MAPGEN& tmg
               ) { m_tmg = tmg; }
         
            void SetXScale (
               double xscale
               ) { m_XScale = (xscale == 0.0) ? 1.0 : xscale; }   
         
            void SetYScale (
               double yscale
               ) { m_YScale = (yscale == 0.0) ? 1.0 : yscale; }   
         
            void SetZScale (
               double zscale
               ) { m_ZScale = (zscale == 0.0) ? 1.0 : zscale; }   
         
            void SetZOffset (
               double zoffset
               ) { m_ZOffset = zoffset; } 
         
         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT

            TRANS2D_MAPGEN m_tmg;
            SPATREF::COORDREFSYS m_CoordRefSys;
            UOM::UNIT m_UnitCalcDistance;
            double m_XScale;
            double m_YScale;
            double m_ZScale;
            double m_ZOffset;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };
         
      static ERRVALUE BuildTable (
         const RVC::GEOMETRIC& GeoObj,
         ELEMTYPE ElemType,
         ADDSTAT AddStats = ADDSTAT_None, 
         TABLEFLAG TableFlag = TABLEFLAG_None
         );

      MSTDATT (
         );
         
      virtual ~MSTDATT (
         ) = 0;

      INT32 GetNumRecords (
         ) const;

      const RVC::DBTABLE& GetStatTable (
         ) const { return (m_TableObj); }
         
      ERRVALUE RebuildTable (
         ADDSTAT AddStats = ADDSTAT_None
         );

   protected:

      virtual void v_CheckFields ();
      virtual RVC::DBTABLE::ATTACHMENT GetAttachmentType () = 0;
      virtual const ATTDEF* GetAttribDef () = 0;
      virtual RVC::DBTABLE::REFELEM GetRefElem () = 0;
      virtual void v_GetTableDescriptor (RVC::DESCRIPTOR& Descriptor) = 0;
      virtual ERRVALUE RebuildBaseTable () = 0;
      virtual bool v_SkipTable (RVC::DBTABLE::REFELEM RefElem) const;

      INT32 AddRecord (const MSTATDATA& StatValues);
      bool DoConvertToSqMeters () const;
      const COMPSTAT& GetCompStat () const { return (m_CompStat); }
      ERRVALUE GetPolygonMaxDim (const POLYLINE& PolyLine, MSTATDATA& StatValues);
      bool HasField (int index) const { return (m_FieldIndex[index] > -1); }
      ERRVALUE ReadRecord (INT32 RecordNum, MSTATDATA& StatValues);
      ERRVALUE Setup (const RVC::GEOMETRIC& GeoObj, RVC::DBASE& DBaseObj, ADDSTAT AddStats = ADDSTAT_None, TABLEFLAG TableFlag = TABLEFLAG_None);     
      ERRVALUE WriteRecord (INT32 RecordNum, const MSTATDATA& StatValues);
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      class STDATTRECORD : public RVC::DBTABLE::RECORD {
         public:  
         
            STDATTRECORD (
               ) : RECORD() {}
         
            STDATTRECORD (
               const STDATTRECORD& rhs
               ) : RECORD(rhs) {}
               
            STDATTRECORD (
               const RVC::DBTABLE& table
               ) : RECORD(table) {}

            virtual ~STDATTRECORD (
               ) {}
         
            STDATTRECORD& operator= (
               const STDATTRECORD& rhs
               ) {
               RECORD::operator=(rhs);
               return (*this);
               }
            
            const void *const GetFieldPtr (
               INT32 FieldNum
               ) const {                              
               return (RECORD::GetFieldPtr(FieldNum));
               }

            void *GetFieldPtr (
               INT32 FieldNum
               ) { return (RECORD::GetFieldPtr(FieldNum)); }

         };

      class OBSERVER : public RVC::DBASE::OBSERVER {
         public:  
            explicit OBSERVER (
               MSTDATT& StdAtt
               ) :
               RVC::DBASE::OBSERVER(*StdAtt.m_DBaseObj),
               m_StdAtt(StdAtt)
               {}
               
            virtual ~OBSERVER (
               ) {}
               
            virtual void OnTableDropBegin (
               INT32 TableNum
               );

         private:
            MSTDATT& m_StdAtt;      
         };
      friend class OBSERVER;
      
      MSTDATT (const MSTDATT& rhs);
      MSTDATT& operator= (const MSTDATT& rhs);
         
      ERRVALUE BuildFields (const RVC::DBTABLE::FIELDINFOARRAY& dbf);
      
      COMPSTAT m_CompStat;
      STDATTRECORD m_Record;
      RVC::DBTABLE::FIELDINFOARRAY m_FieldList;
      SIMPLE_ARRAY<INT32> m_FieldIndex;      
      RVC::DBTABLE m_TableObj;
      RVC::DBASE* m_DBaseObj;
      ADDSTAT m_AddStats;
      const ATTDEF *m_AttribDef;
      OBSERVER *m_Observer;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


class VECTSTDATT : public MSTDATT {
   public:

      VECTSTDATT (
         );

      virtual ~VECTSTDATT (
         );

      ERRVALUE GetPolygonArea (
         INT32 PolyNum,
         double& Area
         );
               
      ERRVALUE Setup (
         const RVC::VECTOR& VectObj,
         ELEMTYPE ElemType,
         ADDSTAT AddStats = ADDSTAT_None,
         TABLEFLAG TableFlag = TABLEFLAG_None
         );    

      ERRVALUE UpdateLine (
         INT32 LineNum
         );
         
      ERRVALUE UpdatePolygon (
         INT32 PolyNum
         );
         
      ERRVALUE UpdatePolygonIsleOnly (
         INT32 PolyNum
         );
         
      ERRVALUE UpdatePolygonSet (
         const BITSET& PolySet
         );
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual void v_CheckFields ();
      virtual RVC::DBTABLE::ATTACHMENT GetAttachmentType ();
      virtual const ATTDEF* GetAttribDef ();
      virtual RVC::DBTABLE::REFELEM GetRefElem ();
      virtual void v_GetTableDescriptor (RVC::DESCRIPTOR& Descriptor);
      virtual ERRVALUE RebuildBaseTable ();
      ERRVALUE GetPolygonStats (INT32 PolyNum, MSTATDATA& StatValues);     
      ERRVALUE RebuildLineTable ();
      ERRVALUE RebuildPolygonTable ();
      ERRVALUE UpdateIslands (INT32 PolyNum, INT32 NumIslands, MSTATDATA& StatValues);
         
      RVC::VECTOR m_VectObj;
      RVC::DBASE_LINE m_LineDBaseObj;
      RVC::DBASE_POLYGON m_PolyDBaseObj;
      ELEMTYPE m_ElemType;
      bool m_HasMaxDimField;
      bool m_HasPointInPolyField;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


class CADSTDATT : public MSTDATT {
   public:

      CADSTDATT (
         );

      virtual ~CADSTDATT (
         );

      ERRVALUE Setup (
         const RVC::CAD& CadObj,
         ADDSTAT AddStats = ADDSTAT_None,
         TABLEFLAG TableFlag = TABLEFLAG_None
         );    

      ERRVALUE UpdateElement (
         const RVC::CAD::ELEMENT& Element
         );
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual void v_CheckFields ();
      virtual RVC::DBTABLE::ATTACHMENT GetAttachmentType ();
      virtual const ATTDEF* GetAttribDef ();
      virtual RVC::DBTABLE::REFELEM GetRefElem ();
      virtual void v_GetTableDescriptor (RVC::DESCRIPTOR& Descriptor);
      virtual ERRVALUE RebuildBaseTable ();
      ERRVALUE RebuildCADTable ();
      
      RVC::CAD m_CadObj;
      RVC::DBASE_CAD m_DBaseObj;
      bool m_HasMaxDimField;
      bool m_HasPointInPolyField;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


class TINSTDATT : public MSTDATT {
   public:

      TINSTDATT (
         );

      virtual ~TINSTDATT (
         );

      ERRVALUE Setup (
         const RVC::TIN& TinObj,
         ELEMTYPE ElemType,
         ADDSTAT AddStats = ADDSTAT_None,
         TABLEFLAG TableFlag = TABLEFLAG_None
         );    

      ERRVALUE UpdateEdge (
         INT32 EdgeNum
         );
         
      ERRVALUE UpdateTriangle (
         INT32 TriangleNum
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual RVC::DBTABLE::ATTACHMENT GetAttachmentType ();
      virtual const ATTDEF* GetAttribDef ();
      virtual RVC::DBTABLE::REFELEM GetRefElem ();
      virtual void v_GetTableDescriptor (RVC::DESCRIPTOR& Descriptor);
      virtual ERRVALUE RebuildBaseTable ();
      virtual bool v_SkipTable (RVC::DBTABLE::REFELEM RefElem) const;
      ERRVALUE RebuildTINEdgeTable ();
      ERRVALUE RebuildTINTriangleTable ();
         
      RVC::TIN m_TinObj;
      RVC::DBASE_TINEDGE m_EdgeDBaseObj;
      RVC::DBASE_TINTRIANGLE m_TriDBaseObj;
      ELEMTYPE m_ElemType;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(MSTDATT::ADDSTAT)
DEFINE_ENUM_OP_BITWISE(MSTDATT::TABLEFLAG)
#endif

}     // End of RVC namespace

#endif   // INC_RVC_MSTDATT_H

---