gre/3dgeomet.h

Go to the documentation of this file.

/*** 
 * \file gre/3dgeomet.h
 * \brief Base class for geometric algorithm
 *
 * \if NODOC
 * $Id: 3dgeomet.h_v 1.8 2006/09/18 15:43:41 mju Exp $
 *
 * $Log: 3dgeomet.h_v $
 * Revision 1.8  2006/09/18 15:43:41  mju
 * Don't inline virtuals.
 *
 * Revision 1.7  2006/02/03 16:58:06  vdronov
 * removed static init...
 *
 * Revision 1.6  2005/10/27 13:06:20  mju
 * Use gre namespace instead of legacy types.
 *
 * Revision 1.5  2005/10/05 15:39:02  mju
 * Include gre base hdr.
 *
 * Revision 1.4  2005/03/15 18:49:07  mju
 * Remove incorrect comment.
 *
 * Revision 1.1  2005/02/01 17:25:31  vdronov
 * Initial revision
 *
 * \endif
**/ 

#ifndef  INC_GRE_3DGEOMET_H
#define  INC_GRE_3DGEOMET_H

#ifndef  INC_GRE_BASE_H
#include <gre/base.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_3DGMELEM_H
#include <gre/3dgmelem.h>
#endif

namespace GRE {

#ifndef GENERATING_DOXYGEN_OUTPUT
class CONTROLLER;
class TERRAIN;
class DRAWINGCONTEXT3D;
class GEOMETRIC3D_ELEMENTS;
#endif // GENERATING_DOXYGEN_OUTPUT


//! Base class for 3D geometric models.
class GEOMETRIC3D {
public:

   class IMPL_FACTORY {
      public:
         virtual GEOMETRIC3D *v_ConstructImpl () = 0;
      };

#define  DECLARE_GEOMETRIC3D_IMPL_FACTORY(name,model)                   \
   class GEOMETRIC3D_IMPL_FACTORY_##name : public GRE::GEOMETRIC3D::IMPL_FACTORY {  \
      public:                                               \
      GEOMETRIC3D_IMPL_FACTORY_##name (                              \
      ) { GRE::GEOMETRIC3D::Register(this,model); }                     \
      virtual GRE::GEOMETRIC3D *v_ConstructImpl () {                    \
      return (new GRE::name);                                  \
         }                                               \
      };                                                 \
   static GEOMETRIC3D_IMPL_FACTORY_##name s_Geometric3DImplFactory_##name;

   enum MODEL {
      MODEL_Default = 0,
      MODEL_Vector = 0,
      MODEL_CAD = 1,
      MODEL_Shape = 2,
      MODEL_Pinmap = 3,
      MODEL_TIN = 4,
      MODEL_Count = 5
      };

   static void Register (
      IMPL_FACTORY* factory,
      const MODEL model
      );

   //! GetName returns a name of the given model enum
   //!
   //! @return char pointer of the name
   static const char* GetName (
      MODEL model
      );

   //! GetDescription returns a description of the given model enum
   //!
   //! @return char pointer of the description
   static const char* GetDescription (
      MODEL model
      );

   //! GetInstance returns a new instance of the given model enum
   //!
   //! @return pointer to new model
   static GEOMETRIC3D* GetInstance (
      MODEL model
      );

   virtual ~GEOMETRIC3D (                       //! Destructor
      );

   //! GetName returns a name of the model
   //!
   //! @return char pointer of the name
   const char* GetName (
      ) const;

   //! GetDescription returns a description of the model
   //!
   //! @return char pointer of the description
   const char* GetDescription (
      ) const;

   //! GetModel returns an enum of the model
   //!
   //! @return enum of the model
   const MODEL GetModel (
      ) const {return m_Model; };

   //! Create new instance of geometric model
   //!
   //! @return instance of geometric model
   GEOMETRIC3D* CreateInstance (
      ) { return v_CreateInstance(); };

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

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

   //!   Build internal structures for geometric construction for given drape layer 
   //!
   //! @return 0 if built or < 0 if an error
   ERRVALUE Build (
      const GRE::LAYER* layer
      ) { return v_Build(layer); };

   //!   Free internal structures for geometric construction 
   void Free (
      ) { v_Free(); return; };

   //!   Is internal structures for geometric construction built? 
   //!
   //! @return true if built or false if an error
   bool IsBuilt (
      );

   //!   Draw given geometric
   //!
   //! @return >= 0 if set is done
   void SetScene (
      SCENE3D& scene
      ) { 
      m_Scene = &scene; 
      m_Viewer = DPOINT3D(m_Scene->GetViewer().x, m_Scene->GetViewer().y, m_Scene->GetViewer().z);
      m_Direction = DPOINT3D(m_Scene->GetDirection().x, m_Scene->GetDirection().y, m_Scene->GetDirection().z);
      return; 
      };

   //!   Draw given geometric
   //!
   //! @return >= 0 if set is done
   ERRVALUE DrawScene (
      CONTROLLER &controller,        
      DRAWINGCONTEXT3D& drawing,
      TERRAIN* terrain,
      const bool wireframe = false
      );

   //! Get extents in map projection coordinates
   //!
   //! @return extents
   const DRECT3D& GetExtents (
      ) { return v_GetExtents(); };

   //! Set model map projection be used for output data
   void SetCoordRefSys (
      const SPATREF::COORDREFSYS& CoordRefSys
      ) { v_SetCoordRefSys(CoordRefSys); return; };

   //! Get map projection be used for output data 
   const SPATREF::COORDREFSYS GetCoordRefSys (
      ) { return v_GetCoordRefSys(); };


   //! Get transformation from object coordinates to specifyed map projection
   //!
   //! @return TRANS2D_MAPGEN&
   const TRANS2D_MAPGEN& GetTransformationInternalToModel (
      ) { return v_GetTransformationInternalToModel(); };

protected:

   GEOMETRIC3D (  
      const char* name,
      const char* desc,
      const MODEL model
      );

   //!   Set built state? 
   void SetBuilt (
      const bool built
      );

   void AppendElements (
      GEOMETRIC3D_ELEMENTS* elements
      ) { m_ElementsArray.Append(elements); return; };

   void ClearElements (
      );

   double ComputeScaleForPoint (
      const DPOINT2D& point
      );

private:

   #ifndef GENERATING_DOXYGEN_OUTPUT

   class BUILDER_IMPL : public GEOMETRIC3D_BUILDER {
   public :

      BUILDER_IMPL (
         const GEOMETRIC3D& geometric
         ) : m_Geometric(geometric) {};

      ~BUILDER_IMPL (
         ) {};

   private:

      const GEOMETRIC3D& m_Geometric;

      BUILDER_IMPL (
         );

      void OnConstruction (
         GRE::TRIANGULATION& triangulation
         );

      void OnConstruction (
         GRE::PIXALIZATION& pixalization
         );

      friend class GEOMETRIC3D;
      };

   static IMPL_FACTORY* s_ImplFactories[MODEL_Count];

   const char* m_Name;
   const char* m_Description;
   const MODEL m_Model;
   BUILDER_IMPL m_Builder;

   bool m_Built;                             //!<  Is an object built?

   SCENE3D *m_Scene;
   DPOINT3D m_Viewer;
   DPOINT3D m_Direction;
   CONTROLLER* m_Controller;
   DRAWINGCONTEXT3D* m_Drawing;
   TERRAIN* m_Terrain;

   GEOMETRIC3D_ELEMENTS_ARRAY m_ElementsArray;

   GEOMETRIC3D (  
      );

   GEOMETRIC3D (                                //! Copy constructor (not implemented)
      const GEOMETRIC3D &rhs
      );

   GEOMETRIC3D& operator= (                        //! Assignment operator (not implemented)
      const GEOMETRIC3D& rhs
      );

   #endif // GENERATING_DOXYGEN_OUTPUT

   virtual GEOMETRIC3D* v_CreateInstance (
      ) = 0;

   virtual ERRVALUE v_Build (
      const GRE::LAYER *layer
      ) = 0;

   virtual void v_Free (
      ) = 0;

   virtual const DRECT3D& v_GetExtents (
      ) = 0;

   virtual void v_SetCoordRefSys (
      const SPATREF::COORDREFSYS& CoordRefSys
      ) = 0;

   virtual const SPATREF::COORDREFSYS v_GetCoordRefSys (
      ) = 0;

   virtual const TRANS2D_MAPGEN& v_GetTransformationInternalToModel (
      ) = 0;

   virtual void OnDrawBegin (GRE::GEOMETRIC3D_BUILDER* builder, const bool wireframe = false);

   virtual void OnDrawEnd ();

   };

}     // End of GRE namespace

#endif

---