mstdatt.h

Go to the documentation of this file.

/**
*  \file rvc\msdtatt.h
*  \brief Class definition of object statistics management store in database
*
*  \if NODOC
*  $Id: mstdatt.h_v 1.8 2004/11/02 16:18:41 scowan Exp $
*
*  $Log: mstdatt.h_v $
*  Revision 1.8  2004/11/02 16:18:41  scowan
*  Added compstat method.
*
*  Revision 1.7  2004/08/23 20:19:32  scowan
*  Changed to use new cad element.
*
*  Revision 1.6  2003/09/30 16:52:06  dwilliss
*  Doxygen
*
*  Revision 1.5  2003/09/25 21:56:58  dwilliss
*  doxygen
*
*  Revision 1.4  2003/09/15 13:49:45  fileserver!dwilliss
*  Doxygen
*
*  Revision 1.3  2003/01/24 16:38:10  scowan
*  Fixed g++ warning.
*
*  Revision 1.2  2002/04/08 16:18:06  scowan
*  Database name changes.
*
*  Revision 1.1  2001/09/18 14:12:02  scowan
*  Initial revision
*
*  \endif
**/

#ifndef  INC_RVC_MSTDATT_H
#define  INC_RVC_MSTDATT_H

#ifndef  INC_MI32_STDDEFNS_H
   #include <mi32/stddefns.h>
#endif

#ifndef  INC_MI32_ELEMTYPE_H
   #include <mi32/elemtype.h>
#endif

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

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

#ifndef  INC_MI32_BITSET_H
   #include <mi32/bitset.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

#ifndef  INC_RVC_DBTABLE_H
   #include <rvc/dbtable.h>
#endif

struct MSTATDATA;

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,
               MSTATDATA& StatValues
               ) const;

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

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

            double GetXScale (
               ) const { return (m_XScale); }
               
            double GetYScale (
               ) const { return (m_YScale); }
               
            void SetCoordRefSys (
               const SPATREF::COORDREFSYS& CoordRefSys
               ) { m_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;
            double m_XScale;
            double m_YScale;
            double m_ZScale;
            double m_ZOffset;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };
         
      // STATIC METHODS
      static ERRVALUE BuildTable (
         const RVC::GEOMETRIC& GeoObj,
         ELEMTYPE ElemType,
         ADDSTAT AddStats = ADDSTAT_None, 
         TABLEFLAG TableFlag = TABLEFLAG_None
         );

      // CONSTRUCTORS / DESTRUCTOR
      MSTDATT (
         );
         
      virtual ~MSTDATT (
         ) = 0;

      //METHODS
      INT32 GetNumRecords (
         ) const;

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

   protected:

      virtual void CheckFields () { return;  }
      virtual RVC::DBTABLE::ATTACHMENT GetAttachmentType () = 0;
      virtual const ATTDEF* GetAttribDef () = 0;
      virtual RVC::DBTABLE::REFELEM GetRefElem () = 0;
      virtual void GetTableDesc (RVC::OBJECTDESC& desc) = 0;
      virtual void GetTableName (RVC::OBJECTNAME& name) = 0;
      virtual ERRVALUE RebuildBaseTable () = 0;
      virtual bool SkipTable (RVC::DBTABLE::REFELEM RefElem) const { return (false); }

      INT32 AddRecord (const MSTATDATA& StatValues);
      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:  
         
            //! Default constructor    
            STDATTRECORD (
               ) : RECORD() {}
         
            //! Copy constructor    
            STDATTRECORD (
               const STDATTRECORD& rhs
               ) : RECORD(rhs) {}
               
            //! Constructor from RVC::DBTABLE - used to setup internal items
            STDATTRECORD (
               const RVC::DBTABLE& table
               ) : RECORD(table) {}

            //! Destructor       
            virtual ~STDATTRECORD (
               ) {}
         
            //! Assignment
            STDATTRECORD& operator= (
               const STDATTRECORD& rhs
               ) {
               RECORD::operator=(rhs);
               return (*this);
               }
            
            const void *const GetFieldPtr (
               INT32 FieldNum
               ) const {                              //! const_cast because G++ is being stupid, promoting to const should not be an error
               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)
               {}
               
            //! Destructor
            virtual ~OBSERVER (
               ) {}
               
            //! Called if a table is being dropped from the database
            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;      //!<  Index from [LINE|POLY|CAD]ATTDEF array to field entry 
      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 CheckFields ();
      virtual RVC::DBTABLE::ATTACHMENT GetAttachmentType ();
      virtual const ATTDEF* GetAttribDef ();
      virtual RVC::DBTABLE::REFELEM GetRefElem ();
      virtual void GetTableDesc (RVC::OBJECTDESC& desc);
      virtual void GetTableName (RVC::OBJECTNAME& name);
      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 CheckFields ();
      virtual RVC::DBTABLE::ATTACHMENT GetAttachmentType ();
      virtual const ATTDEF* GetAttribDef ();
      virtual RVC::DBTABLE::REFELEM GetRefElem ();
      virtual void GetTableDesc (RVC::OBJECTDESC& desc);
      virtual void GetTableName (RVC::OBJECTNAME& name);
      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 GetTableDesc (RVC::OBJECTDESC& desc);
      virtual void GetTableName (RVC::OBJECTNAME& name);
      virtual ERRVALUE RebuildBaseTable ();
      virtual bool 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
   };

DEFINE_ENUM_OPERATORS(MSTDATT::ADDSTAT)
DEFINE_ENUM_OPERATORS(MSTDATT::TABLEFLAG)

}     //! End of RVC namespace

#endif         //!< INC_RVC_MSTDATT_H

---