gre/3dgmelem.h

Go to the documentation of this file.

/*** 
 * \file 3dgmelem.h <gre/3dgmelem.h>
 * \brief Geometrical elements
 *
 * \if NODOC
 * $Id: 3dgmelem.h_v 1.22 2011/12/23 15:00:39 mju Exp $
 *
 * $Log: 3dgmelem.h_v $
 * Revision 1.22  2011/12/23 15:00:39  mju
 * Use mg2enums hdr.
 *
 * Revision 1.21  2011/12/23 14:58:15  mju
 * Fwd declare labelstyle.
 *
 * Revision 1.20  2011/10/11 13:19:18  mju
 * Remove unneeded hdrs.
 *
 * Revision 1.19  2010/11/05 14:05:55  mju
 * Use new triangulator class.
 *
 * Revision 1.15  2006/09/20 14:50:35  scowan
 * Thinned out unneeded include files and changed style patterns to current.
 *
 * Revision 1.11  2005/09/12 18:34:19  vdronov
 * added labels rendering
 *
 * Revision 1.10  2005/08/22 20:42:15  vdronov
 * text rendering in 3d
 *
 * Revision 1.9  2005/07/22 21:49:16  vdronov
 * added bitmap pattern rendering
 *
 * Revision 1.4  2005/04/15 15:07:23  vdronov
 * added 3d line rendering
 *
 * Revision 1.1  2005/02/17 18:01:16  vdronov
 * Initial revision
 * \endif
**/ 

#ifndef  INC_GRE_3DGMELEM_H
#define  INC_GRE_3DGMELEM_H

#ifndef  INC_GRE_3DUTILS_H
#include <gre/3dutils.h>
#endif

#ifndef  INC_GRE_3DSCENE_H
#include <gre/3dscene.h>
#endif

#ifndef  INC_GRE_3DPNTFLD_H
#include <gre/3dpntfld.h>
#endif

#ifndef  INC_MI32_TRIANGULATOR_H
#include <mi32/triangulator.h>
#endif

#ifndef  INC_MI32_MG2ENUMS_H
#include <mi32/mg2enums.h>
#endif

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


#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward declarations.
class REGION2D;
class SUBREGION2D;
class LABELSTYLE;
namespace RVC {
   class STYLE;
   class STYLEPATTERN_BITMAP;
   class STYLEPATTERN_HATCH;
   class STYLEPATTERN_LINE;
   class STYLEPATTERN_SYMBOL;
   }
namespace GRE {
   struct TRIANGULATION;
   class  TERRAIN;
   class LABELPLACE;
   }
#endif


namespace GRE {

class GEOMETRIC3D_BUILDER {
   public:

      enum ELEMMODE {
         ELEMMODE_Standard,
         ELEMMODE_Highlighted,
         ELEMMODE_Active
         };

      ERRVALUE DrawPoint2D (
         const DPOINT2D& point, 
         const POINTSTYLE& style
         );

      ERRVALUE DrawLabel2D (
         const RVC::VECTOR::LABEL& label, 
         const LABELSTYLE& style
         );

      ERRVALUE DrawPoint3D (
         const DPOINT3D& point, 
         const POINTSTYLE& style
         );

      ERRVALUE DrawLine2D (
         const POLYLINE& polyline, 
         const LINESTYLE& style,
         const RVC::STYLEPATTERN_LINE& pattern
         );

      ERRVALUE DrawLine3D (
         const POLYLINE& polyline, 
         const LINESTYLE& style
         );

      ERRVALUE DrawRectangle2D (
         const DRECT2D& rect, 
         const LINESTYLE& style,
         const RVC::STYLEPATTERN_LINE& pattern
         );

      ERRVALUE DrawCircle2D (
         const DPOINT2D& center, 
         const double radius, 
         const LINESTYLE& style,
         const RVC::STYLEPATTERN_LINE& pattern
         );

      ERRVALUE DrawPolygon2D (
         const POLYLINE& polyline, 
         const POLYSTYLE& style//,
         //const RVC::STYLEPATTERN_LINE& pattern
         );

      ERRVALUE DrawSubRegion2D (
         const SUBREGION2D& subregion, 
         const POLYSTYLE& style//,
         //const RVC::STYLEPATTERN_LINE& pattern
         );

      ERRVALUE DrawRegion2D (
         const REGION2D& region, 
         const POLYSTYLE& style//,
         //const RVC::STYLEPATTERN_LINE& pattern
         );

      ERRVALUE FillPoint2D (
         const DPOINT2D& point, 
         const POINTSTYLE& style,
         const RVC::STYLEPATTERN_SYMBOL& pattern
         );

      ERRVALUE FillLabel2D (
         const RVC::VECTOR::LABEL& label, 
         const LABELSTYLE& style,
         const RVC::STYLE& styleobj
         );

      ERRVALUE FillLabel2D (
         const GRE::LABELPLACE& labelplace, 
         const RVC::STYLE& styleobj
         );

      ERRVALUE FillLabel2D (
         const MIUNICODE* text,
         const POLYLINE& base,
         const LABELSTYLE& style,
         const POLYLINELIST& leaders,
         const RVC::STYLE& styleobj
         );

      ERRVALUE FillPoint3D (
         const DPOINT3D& point, 
         const POINTSTYLE& style
         );

      ERRVALUE FillLine2D (
         const POLYLINE& polyline, 
         const LINESTYLE& style,
         const RVC::STYLEPATTERN_LINE& pattern,
         const MGD::LINECAP linecap = MGD::LINECAP_Butt
         );

      ERRVALUE FillLine3D (
         const POLYLINE& polyline, 
         const LINESTYLE& style
         );

      ERRVALUE FillRectangle2D (
         const DRECT2D& rect, 
         const POLYSTYLE& style,
         const RVC::STYLE& styleobj
         );

      ERRVALUE FillCircle2D (
         const DPOINT2D& center, 
         const double radius, 
         const POLYSTYLE& style,
         const RVC::STYLE& styleobj
         );

      ERRVALUE FillPolygon2D (
         const POLYLINE& polyline, 
         const POLYSTYLE& style,
         const RVC::STYLE& styleobj
         );

      ERRVALUE FillSubRegion2D (
         const SUBREGION2D& subregion, 
         const POLYSTYLE& style,
         const RVC::STYLE& styleobj
         );

      ERRVALUE FillRegion2D (
         const REGION2D& region, 
         const POLYSTYLE& style,
         const RVC::STYLE& styleobj
         );

      double GetFactor (
         ) { return m_SF; }


      ERRVALUE Init (
         GRE::SCENE3D* scene, 
         GRE::TERRAIN* terrain,
         const double s2d
         );

      void Clear (
         ) {
         m_Scene = 0; 
         m_Terrain = 0;
         }

      void SetHighlightedColor (
         const COLOR color
         ) { m_HighlightedColor = color; }

      void SetActiveColor (
         const COLOR color
         ) { m_ActiveColor = color; }

      void SetElementsMode (
         const ELEMMODE mode
         ) { m_ElementsMode = mode; }

      void Translate (
         const DPOINT2D& input,   // map coordinates
         const DPOINT2D& offset,  // in mm
         const double mapscale,   // if <= 0.0 there is no mapscale 
         DPOINT2D& output         // map coordinates
         );

   protected:

      GEOMETRIC3D_BUILDER () {}
      virtual ~GEOMETRIC3D_BUILDER () {}

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      static bool Intersect (
         const FPOINT2D& ps,
         const FPOINT2D& pe,
         const FPOINT2D& qs,
         const FPOINT2D& qe,
         FPOINT2D& p
         );

      static const INT32 s_IcosahedronNumVertices = 12;
      static const INT32 s_IcosahedronNumTriangles = 20;
      static const float s_IcosahedronTriangleArea;

      static const FPOINT3D s_IcosahedronVertices[12];
      static const GRE::TRIANGLEINDEX s_IcosahedronTriangles[20];

      static const double s_FScale;
      static const double s_FXOffset;
      static const double s_FYOffset;

      GRE::SCENE3D* m_Scene; 
      GRE::TERRAIN* m_Terrain;
      DPOINT3D m_Direction;
      DPOINT3D m_Viewer;
      ELEMMODE m_ElementsMode;
      COLOR m_HighlightedColor;
      COLOR m_ActiveColor;
      FPOINT3D m_SunDirection;

      SIMPLE_ARRAY<FPOINT3D> m_Points;
      POLYLINE m_Polyline;
      POLYLINE m_PolylineE;
      SIMPLE_ARRAY<double> m_Offset;
      GRE::TRIANGULATION m_Triangulation;
      GRE::PIXALIZATION m_Pixalization;
      TRIANGULATOR m_Triangulator;
      DOUBLE_ARRAY<DTRIANGLE2D> m_Triangles;

      double m_S2D;
      double m_S3D;
      double m_SF;

      virtual void OnConstruction (
         GRE::TRIANGULATION& triangulation
         ) = 0;

      virtual void OnConstruction (
         GRE::PIXALIZATION& pixalization
         ) = 0;

      ERRVALUE DrawSegment2D (
         const FPOINT2D& pt1,
         const FPOINT2D& pt2,
         const COLOR& color
         );

      ERRVALUE OutlinePolygon2D (
         const POLYLINE& polyline, 
         const float thickness,
         const COLOR& color,
         const MGD::LINEJOIN linejoin = MGD::LINEJOIN_Round
         );

      ERRVALUE OutlineSubRegion2D (
         const SUBREGION2D& subregion, 
         const float thickness,
         const COLOR& color,
         const MGD::LINEJOIN linejoin = MGD::LINEJOIN_Round
         );

      ERRVALUE OutlineRegion2D (
         const REGION2D& region, 
         const float thickness,
         const COLOR& color,
         const MGD::LINEJOIN linejoin = MGD::LINEJOIN_Round
         );

      ERRVALUE FillPoint2DBuildIn (
         const DPOINT2D& point, 
         const POINTSTYLE& style
         );

      ERRVALUE FillPoint2DUseSymbol (
         const DPOINT2D& point, 
         const POINTSTYLE& style,
         const RVC::STYLEPATTERN_SYMBOL& pattern
         );

      ERRVALUE FillPoint3DBuildIn (
         const DPOINT3D& point, 
         const POINTSTYLE& style
         );

      ERRVALUE FillPoint3DUseSymbol (
         const DPOINT3D& point, 
         const POINTSTYLE& style
         );

      ERRVALUE FillLine2DSolid (
         const POLYLINE& polyline, 
         const LINESTYLE& style,
         const MGD::LINECAP linecap = MGD::LINECAP_Round
         );

      ERRVALUE FillLine2DSolid (
         const POLYLINE& polyline, 
         const float thickness,
         const COLOR& color,
         const MGD::LINEJOIN linejoin = MGD::LINEJOIN_Round,
         const MGD::LINECAP linecap = MGD::LINECAP_Round
         );


      ERRVALUE FillLine2DUsePattern (
         const POLYLINE& polyline, 
         const LINESTYLE& style,
         const RVC::STYLEPATTERN_LINE& pattern
         );

      ERRVALUE FillLine3DSolid (
         const POLYLINE& polyline, 
         const LINESTYLE& style
         );

      ERRVALUE FillLine3DUsePattern (
         const POLYLINE& polyline, 
         const LINESTYLE& style
         );

      ERRVALUE FillTriangle2D (
         const FPOINT2D& pt1,
         const FPOINT2D& pt2,
         const FPOINT2D& pt3,
         const COLOR& color
         );

      ERRVALUE FillTriangle2D (
         const FPOINT2D& pt1,
         const FPOINT2D& pt2,
         const FPOINT2D& pt3,
         const COLOR& color,
         const RVC::STYLEPATTERN_BITMAP& pattern
         );

      ERRVALUE FillRectangle2D (
         const DRECT2D& rectangle,
         const COLOR& color
         );

      ERRVALUE FillTriangle3D (
         const FPOINT3D& pt1,
         const FPOINT3D& pt2,
         const FPOINT3D& pt3,
         const COLOR& color
         );

      ERRVALUE DrawCircle2D (
         const FPOINT2D& point,
         const float radius,
         const float thickness,
         const COLOR& color
         );

      ERRVALUE DrawArc2D (
         const FPOINT2D& point,
         const float radius,
         const float thickness,
         const float start,
         const float sweep,
         const COLOR& color,
         const MGD::SHAPECLOSE shapeclose = MGD::SHAPECLOSE_None
         );

      ERRVALUE DrawEllipse2D (
         const FPOINT2D& point,
         const float x,
         const float y,
         const float thickness,
         const float rotation,
         const COLOR& color
         );

      ERRVALUE FillCircle2D (
         const FPOINT2D& point,
         const float radius,
         const COLOR& color
         );

      ERRVALUE FillArcWedge2D (
         const FPOINT2D& point,
         const float radius,
         const float start,
         const float sweep,
         const COLOR& color
         );

      ERRVALUE FillArcChord2D (
         const FPOINT2D& point,
         const float radius,
         const float start,
         const float sweep,
         const COLOR& color
         );

      ERRVALUE FillArcChord(
         const FPOINT2D& point1,
         const FPOINT2D& point2,
         const FPOINT2D& center,
         const float radius,
         const COLOR& color
         );

      ERRVALUE FillEllipse2D (
         const FPOINT2D& point,
         const float x,
         const float y,
         const float rotation,
         const COLOR& color
         );

      ERRVALUE FillSphericalTriangle3D (
         const FPOINT3D& center,
         const float radius,
         const INT32 depth,
         const FPOINT3D& pt1,
         const FPOINT3D& pt2,
         const FPOINT3D& pt3,
         const COLOR& color
         );

      ERRVALUE FillSphere3D (
         const FPOINT3D& center,
         const float radius,
         const COLOR& color
         );

      ERRVALUE FillCube3D (
         const FPOINT3D& center,
         const float x,
         const float y,
         const float z,
         const COLOR& color
         );

      ERRVALUE FillCylindricalRectangle3D (
         const FPOINT3D& scenter,
         const float sradius,
         const FPOINT3D& ecenter,
         const float eradius,
         const FPOINT3D& n1,
         const FPOINT3D& n2,
         const INT32 depth,
         const COLOR& color
         );

      ERRVALUE FillCylinder3D (
         const FPOINT3D& scenter,
         const float sradius,
         const FPOINT3D& ecenter,
         const float eradius,
         const COLOR& color
         );

      ERRVALUE FillTriangles2DSolid (
         const DOUBLE_ARRAY<DTRIANGLE2D>& triangles,
         const COLOR& color
         );

      ERRVALUE FillTriangles2DUseBitmap (
         const DOUBLE_ARRAY<DTRIANGLE2D>& triangles,
         const POLYSTYLE& style,
         const RVC::STYLEPATTERN_BITMAP& pattern
         );

      DRECT2D ComputeExtents (
         const DOUBLE_ARRAY<DTRIANGLE2D>& triangles
         );

      ERRVALUE FillRectangle2DUseHatch (
         const DRECT2D& extents,
         const POLYSTYLE& style,
         const RVC::STYLEPATTERN_HATCH& pattern
         );

      ERRVALUE FillBorder2DSolid (
         const POLYLINE& polyline, 
         const POLYSTYLE& style
         );

      ERRVALUE FillBorder2DSolid (
         const POLYLINE& polyline, 
         const float thickness,
         const COLOR& color,
         const MGD::LINEJOIN linejoin = MGD::LINEJOIN_Round
         );

      ERRVALUE FillBorder2DUsePattern (
         const POLYLINE& polyline, 
         const POLYSTYLE& style,
         const RVC::STYLEPATTERN_LINE& pattern
         );

      ERRVALUE FillPolygon2D (
         const POLYLINE& polyline, 
         const bool fill,
         const float thickness,
         const COLOR& color,
         const MGD::LINEJOIN linejoin = MGD::LINEJOIN_Round
         );

      ERRVALUE FillSubRegion2D (
         const SUBREGION2D& subregion, 
         const bool fill,
         const float thickness,
         const COLOR& color,
         const MGD::LINEJOIN linejoin = MGD::LINEJOIN_Round
         );

      ERRVALUE FillRegion2D (
         const REGION2D& region, 
         const bool fill,
         const float thickness,
         const COLOR& color,
         const MGD::LINEJOIN linejoin = MGD::LINEJOIN_Round
         );

      void ApplyAffineForward (
         const TRANS2D_AFFINE& affine, 
         FPOINT2D& point
         );

      void ApplyAffineInverse (
         const TRANS2D_AFFINE& affine, 
         FPOINT2D& point
         );

      void SetMask (
         const DOUBLE_ARRAY<DTRIANGLE2D> triangles,
         GRE::POINTSFIELD& PointsField
         );

      void ClearMask (
         GRE::POINTSFIELD& PointsField
         );

      ERRVALUE DrawPixels (
         SIMPLE_ARRAY<FPOINT3D>& points,
         const COLOR& color
         );

      ERRVALUE DrawPixels (
         SIMPLE_ARRAY<FPOINT3D>& points,
         const COLOR& color,
         const RVC::STYLEPATTERN_BITMAP& pattern
         );

      ERRVALUE DrawTriangle3D (
         const FPOINT3D& pt1,
         const FPOINT3D& pt2,
         const FPOINT3D& pt3,
         const COLOR& color
         );

      ERRVALUE ConstructScales ();
      double GetElevation( const double x, const double y);

      #endif // GENERATING_DOXYGEN_OUTPUT
   };


class GEOMETRIC3D_ELEMENTS {
   public:

      class ITERATOR_BASE {
         public:

            virtual ~ITERATOR_BASE (
               ) {}

            // Dereference operator
            virtual INT32 operator* (
               ) const = 0;
         
            // Pre-increment operator.
            virtual ITERATOR_BASE* operator++ (
               ) = 0;

            // Equality operator.
            virtual bool operator== (
               const ITERATOR_BASE* rhs
               ) const = 0;

            // Inequality operator.
            virtual bool operator!= (
               const ITERATOR_BASE* rhs
               ) const = 0;

         protected:
            ITERATOR_BASE () {}
         };

      class BITSET_ITERATOR_BASE : public ITERATOR_BASE {
         public:

            ~BITSET_ITERATOR_BASE () {}

            void Begin();

            void End();

            INT32 operator* () const;
         
            GRE::GEOMETRIC3D_ELEMENTS::ITERATOR_BASE* operator++ ();

            bool operator== (
               const GRE::GEOMETRIC3D_ELEMENTS::ITERATOR_BASE* rhs
               ) const;

            bool operator!= (
               const GRE::GEOMETRIC3D_ELEMENTS::ITERATOR_BASE* rhs
               ) const;
         
         protected:

            BITSET_ITERATOR_BASE (const bool selected) : m_Selected(selected) { End(); }

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            const bool m_Selected;
            BITSET m_Bitset;
            BITSET::ITERATOR m_Iterator;

            BITSET_ITERATOR_BASE ();

            virtual ERRVALUE ComputeSelectedElements (BITSET& bitset) = 0;
            virtual ERRVALUE ComputeHighlightedElements (BITSET& bitset) = 0;
            #endif
         };

      class ITERATOR {
         public:

            ITERATOR () : m_Base(0) {}
            ~ITERATOR () {}

            // Dereference operator
            INT32 operator* (
               ) const {return m_Base->operator*();}
      
            // Pre-increment operator.
            ITERATOR& operator++ (
               ) {m_Base->operator++(); return *this; }

            // Equality operator.
            bool operator== (
               const ITERATOR& rhs
               ) const { return m_Base->operator==(rhs.m_Base); }

            // Inequality operator.
            bool operator!= (
               const ITERATOR& rhs
               ) const { return m_Base->operator!=(rhs.m_Base); }

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT

            ITERATOR (ITERATOR_BASE* base) : m_Base(base) {}

            ITERATOR_BASE *m_Base;

            friend class GEOMETRIC3D_ELEMENTS;
            #endif
         };

      GEOMETRIC3D_ELEMENTS (                          
         ) {}

      virtual ~GEOMETRIC3D_ELEMENTS (                    
         ) {}

      bool IsTerrainNeeded (
         ) { return v_IsTerrainNeeded(); }

      bool IsPointsFieldNeeded (
         ) { return v_IsPointsFieldNeeded(); }

      void ConstructWireframe (
         const INT32 id,
         GEOMETRIC3D_BUILDER* builder
         ) { v_ConstructWireframe(id, builder); }

      void ConstructSolid (
         const INT32 id,
         GEOMETRIC3D_BUILDER* builder
         ) { v_ConstructSolid(id, builder); }

      void OnConstructionBegin (
         const bool wireframe
         ) { v_OnConstructionBegin(wireframe); }

      void OnConstructionEnd (
         ) { v_OnConstructionEnd(); }

      ITERATOR BeginSelected (
         ) { return ITERATOR(GetSelectedBase(true)); }

      ITERATOR EndSelected (
         ) { return ITERATOR(GetSelectedBase(false)); }  

      ITERATOR BeginHighlited (
         ) { return ITERATOR(GetHighlightedBase(true)); }

      ITERATOR EndHighlited (
         ) { return ITERATOR(GetHighlightedBase(false)); }  

      INT32 GetActiveElement (
         ) { return v_GetActiveElement(); }

      INT32 GetNumSelectedElements (
         ) { return v_GetNumSelectedElements(); }

      INT32 GetNumHighlightedElements (
         ) { return v_GetNumHighlightedElements(); }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      friend class ITERATOR;

      virtual ITERATOR_BASE* GetSelectedBase (const bool begin) = 0;
      virtual ITERATOR_BASE* GetHighlightedBase (const bool begin) = 0;
      virtual INT32 v_GetActiveElement () = 0;
      virtual INT32 v_GetNumSelectedElements () = 0;
      virtual INT32 v_GetNumHighlightedElements () = 0;
      virtual void v_ConstructWireframe (const INT32 id, GEOMETRIC3D_BUILDER* builder) = 0;
      virtual void v_ConstructSolid (const INT32 id, GEOMETRIC3D_BUILDER* builder) = 0;
      virtual void v_OnConstructionBegin (const bool /*wireframe*/) { return; }
      virtual void v_OnConstructionEnd () { return; }
      virtual bool v_IsTerrainNeeded () = 0;
      virtual bool v_IsPointsFieldNeeded () = 0;

      #endif // GENERATING_DOXYGEN_OUTPUT
   };

typedef SIMPLE_ARRAY<GEOMETRIC3D_ELEMENTS*> GEOMETRIC3D_ELEMENTS_ARRAY;

}     // End of GRE namespace

#endif

---