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.12 2005/11/11 21:35:25 vdronov Exp $
 *
 * $Log: 3dgmelem.h_v $
 * Revision 1.12  2005/11/11 21:35:25  vdronov
 * *** empty log message ***
 *
 * 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.8  2005/06/02 19:19:48  vdronov
 * *** empty log message ***
 *
 * Revision 1.7  2005/05/20 21:53:28  vdronov
 * *** empty log message ***
 *
 * Revision 1.6  2005/05/05 21:09:52  vdronov
 * finished symbolpattern
 *
 * Revision 1.5  2005/04/29 22:08:34  vdronov
 * *** empty log message ***
 *
 * Revision 1.4  2005/04/15 15:07:23  vdronov
 * added 3d line rendering
 *
 * Revision 1.3  2005/04/08 19:09:31  vdronov
 * *** empty log message ***
 *
 * Revision 1.2  2005/03/10 21:42:44  vdronov
 * *** empty log message ***
 *
 * 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_MI32_BITSET_H
#include <mi32/bitset.h>
#endif

#ifndef  INC_MI32_SIMPLEAR_H
#include <mi32/simplear.h>
#endif

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

#ifndef  INC_MI32_MGD2_H
#include <mi32/mgd2.h>
#endif

#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_TRIANGUL_H
#include <mi32/triangul.h>
#endif

#ifndef  INC_MI32_REGION2D_H
#include <mi32/region2d.h>
#endif

#ifndef  INC_RVC_STYLE_H
#include <rvc/style.h>
#endif

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

namespace GRE {

#ifndef GENERATING_DOXYGEN_OUT
struct TRIANGULATION;
class  TERRAIN;
#endif // GENERATING_DOXYGEN_OUTPUT

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::STYLE::LINEPATTERN& pattern
      );

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

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

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

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

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

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

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

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

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

   ERRVALUE FillLine2D (
      const POLYLINE& polyline, 
      const LINESTYLE& style,
      const RVC::STYLE::LINEPATTERN& 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; };


// MGD::DEVICE& GetDevice () { return m_Device; };

   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; return; };

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

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

protected:

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

private:

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

// class BUILDER_DEVICE : public MGD::DEVICE {
// public:
// private:
//    };

   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;
   TRIANGULATOR2D m_Triangulator;
   SIMPLE_ARRAY<DTRIANGLE2D> m_Triangles;
// BUILDER_DEVICE m_Device;

   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::STYLE::SYMBOLPATTERN& 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::STYLE::LINEPATTERN& 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 GRE::GEOMETRIC3D_BUILDER::FillTriangle2D (
      const FPOINT2D& pt1,
      const FPOINT2D& pt2,
      const FPOINT2D& pt3,
      const COLOR& color,
      const RVC::STYLE::BITMAPPATTERN& 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 SIMPLE_ARRAY<DTRIANGLE2D>& triangles,
      const COLOR& color
      );

   ERRVALUE FillTriangles2DUseBitmap (
      const SIMPLE_ARRAY<DTRIANGLE2D>& triangles,
      const POLYSTYLE& style,
      const RVC::STYLE::BITMAPPATTERN& pattern
      );

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

   ERRVALUE FillRectangle2DUseHatch (
      const DRECT2D& extents,
      const POLYSTYLE& style,
      const RVC::STYLE::HATCHPATTERN& 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::STYLE::LINEPATTERN& 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 SIMPLE_ARRAY<DTRIANGLE2D> triangles,
      GRE::POINTSFIELD& PointsField
      );

   void ClearMask (
      GRE::POINTSFIELD& PointsField
      );

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

   ERRVALUE GRE::GEOMETRIC3D_BUILDER::DrawPixels (
      SIMPLE_ARRAY<FPOINT3D>& points,
      const COLOR& color,
      const RVC::STYLE::BITMAPPATTERN& pattern
      );

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

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

   };


//! GEOMETRIC3D_ELEMENTS class describes base container class of geometric elements
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:

      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;

      };

   class ITERATOR;
   friend class ITERATOR;

   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:

         ITERATOR_BASE *m_Base;

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

         friend class GEOMETRIC3D_ELEMENTS;
         };

   GEOMETRIC3D_ELEMENTS (                          //! Constructor 
      ) {};

   virtual ~GEOMETRIC3D_ELEMENTS (                    //! Destructor 
      ) {};

   //!   Is terrain needed for geometric construction 
   //!
   //! @return true id needed or false if not
   bool IsTerrainNeeded (
      ) { return v_IsTerrainNeeded(); };

   //!   Is points field needed for geometric construction 
   //!
   //! @return true id needed or false if not
   bool IsPointsFieldNeeded (
      ) { return v_IsPointsFieldNeeded(); };

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

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

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

   void OnConstructionEnd (
      ) { v_OnConstructionEnd(); return; };

   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

   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

---