gre/wireframe.h

Go to the documentation of this file.

#ifndef  INC_GRE_WIREFRAME_H
#define  INC_GRE_WIREFRAME_H

#ifndef  INC_GRE_BASE_H
   #include <gre/base.h>
#endif

#ifndef  INC_MI32_POLYLINE_H
   #include <mi32/polyline.h>
#endif

#ifndef  INC_MI32_COLOR_H
   #include <mi32/color.h>
#endif


#ifndef  GENERATING_DOXYGEN_OUTPUT
namespace RVC {
   class DBTABLE;
   class OBJECTOBSERVER;
   }
#endif   // GENERATING_DOXYGEN_OUTPUT


namespace GRE {

class WIREFRAME {
   public:

      WIREFRAME ();

      ~WIREFRAME ();

      ERRVALUE AddExtrudedLine (
         const POLYLINE& PolyLine,
         const DOUBLE_RANGE& ZRange
         );

      ERRVALUE AddExtrudedPoint (
         const DPOINT3D& Point,
         const DOUBLE_RANGE& ZRange
         );

      ERRVALUE AddLine (
         const POLYLINE& PolyLine
         );

      ERRVALUE AddPoint (
         const DPOINT3D& point
         );

      ERRVALUE AddPoints (
         const DPOINT3D* points,
         INT32 NumPoints
         );

      ERRVALUE AttachTableExtrudedLines (
         const RVC::DBTABLE& table           
         );

      ERRVALUE AttachTableExtrudedPoints (
         const RVC::DBTABLE& table           
         );

      void ClearAll ();

      void ClearExtrudedLines (
         );

      void ClearExtrudedPoints (
         );

      void ClearGrid (
         ) { m_grid.Clear(); }

      void ClearLines ();

      void ClearNetwork (
         ) { /*m_network.Clear();*/ }

      ERRVALUE CreateGrid (
         INT32 NumRows,
         INT32 NumColumns,
         const DPOINT2D& ObjectSpacing,
         const DPOINT2D& ObjectOrigin
         ) { return (m_grid.Create(NumRows,NumColumns,ObjectSpacing,ObjectOrigin)); }

      ERRVALUE Draw (
         LAYERDC& layerdc
         );

      bool HasExtrudedLines (
         ) const { return (!m_ExtrudedLines.IsEmpty()); }

      bool HasExtrudedPoints (
         ) const { return (!m_ExtrudedPoints.IsEmpty()); }

      bool HasGrid (
         ) const { return (m_grid.IsCreated()); }

      bool HasLines (
         ) const { return (!m_lines.IsEmpty()); }

      bool HasPoints (
         ) const { return (!m_points.IsEmpty()); }

      void SetGridValues (
         INT32 row,
         INT32 column,
         const double *values,
         const UINT8 *mask,
         INT32 numcolumns = 1
         ) { m_grid.SetValues(row,column,values,mask,numcolumns); }

      void SetExtrudedLineColors (
         const COLOR& ColorBelow,
         const COLOR& ColorAbove
         ) { m_ExtrudedLineColorBelow = ColorBelow; m_ExtrudedLineColorAbove = ColorAbove; }

      void SetExtrudedPointColors (
         const COLOR& ColorBelow,
         const COLOR& ColorAbove
         ) { m_ExtrudedPointColorBelow = ColorBelow; m_ExtrudedPointColorAbove = ColorAbove; }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      // 2D "grid" of Z values at regular spacing
      class GRID {
         public:
            GRID ();
            ~GRID ();
            void Clear ();
            ERRVALUE Create (
               INT32 NumRows,
               INT32 NumColumns,
               const DPOINT2D& ObjectSpacing,
               const DPOINT2D& ObjectOrigin
               );
            ERRVALUE Draw (LAYERDC& layerdc) const;
            bool IsCreated (
               ) const { return (!m_values.IsEmpty()); }
            void SetValues (
               INT32 row,
               INT32 column,
               const double *values,
               const UINT8 *mask,
               INT32 numcolumns = 1
               );

         private:
            DOUBLE_ARRAY<double> m_values;   // Z value at grid position
            DPOINT2D m_ObjectSpacing;        // Grid spacing in object coordinates (usually cells)
            DPOINT2D m_ObjectOrigin;         // Grid origin in object coordinates (usually cells)
            INT32 m_NumRows;                 // Number of rows in grid
            INT32 m_NumColumns;              // Number of columns in grid
         };

      class NETWORK {
         public:
            NETWORK ();
            ~NETWORK ();
            void Clear () { }
            ERRVALUE Draw (LAYERDC&) const { return (0); }

         private:
            struct EDGE {
               INT32 m_NodeFrom;
               INT32 m_NodeTo;
               };
            DOUBLE_ARRAY<DPOINT3D> m_Nodes;
            SIMPLE_ARRAY<EDGE> m_Edges;
         };

      class EXTRUDEDLINE {
         public:
            EXTRUDEDLINE (
               const POLYLINE& PolyLine,
               const DOUBLE_RANGE& ZRange
               );
            ~EXTRUDEDLINE ();
            const POLYLINE& GetPolyLine (
               ) const { return (m_PolyLine); }
            const DOUBLE_RANGE& GetZRange (
               ) const { return (m_ZRange); }
         private:
            POLYLINE m_PolyLine;
            DOUBLE_RANGE m_ZRange;
         };
      typedef MILIST<EXTRUDEDLINE> EXTRUDEDLINELIST;

      class EXTRUDEDPOINT {
         public:
            EXTRUDEDPOINT (
               const DPOINT3D& Point,
               const DOUBLE_RANGE& ZRange
               );
            ~EXTRUDEDPOINT ();
            const DPOINT3D& GetPoint (
               ) const { return (m_Point); }
            const DOUBLE_RANGE& GetZRange (
               ) const { return (m_ZRange); }
         private:
            DPOINT3D m_Point;
            DOUBLE_RANGE m_ZRange;
         };
      typedef MILIST<EXTRUDEDPOINT> EXTRUDEDPOINTLIST;

      GRID m_grid;
      POLYLINELIST m_lines;
      DOUBLE_ARRAY<DPOINT3D> m_points;
      EXTRUDEDLINELIST m_ExtrudedLines;
      EXTRUDEDPOINTLIST m_ExtrudedPoints;
      RVC::DBTABLE *m_pObjTableExtrudedLines;
      RVC::DBTABLE *m_pObjTableExtrudedPoints;
      RVC::OBJECTOBSERVER *m_pObsTableExtrudedLines;
      RVC::OBJECTOBSERVER *m_pObsTableExtrudedPoints;
      COLOR m_ExtrudedLineColorBelow;
      COLOR m_ExtrudedLineColorAbove;
      COLOR m_ExtrudedPointColorBelow;
      COLOR m_ExtrudedPointColorAbove;

      ERRVALUE DrawExtrudedLines (LAYERDC& layerdc) const;
      ERRVALUE DrawExtrudedPoints (LAYERDC& layerdc) const;
      ERRVALUE DrawLines (LAYERDC& layerdc) const;
      ERRVALUE DrawPoints (LAYERDC& layerdc) const;

      void OnChgTableExtrudedLines ();
      void OnChgTableExtrudedPoints ();
      #endif   // GENERATING_DOXYGEN_OUTPUT
   };

}  // End namespace GRE

#endif   // INC_GRE_WIREFRAME_H

---