gre/3dterra.h

Go to the documentation of this file.

/*** 
 * \file 3dterra.h <gre/3dterra.h>
 * \brief Base class for terrain algorithm
 *
 * \if NODOC
 * $Id: 3dterra.h_v 1.32 2005/11/10 20:26:56 vdronov Exp $
 *
 * $Log: 3dterra.h_v $
 * Revision 1.32  2005/11/10 20:26:56  vdronov
 * *** empty log message ***
 *
 * Revision 1.31  2005/10/19 20:07:55  mju
 * Use gre namespace instead of legacy typedefs.
 *
 * Revision 1.30  2005/06/13 16:13:08  vdronov
 * removed sparse triangulation and dense raycasting
 *
 * Revision 1.29  2005/03/31 23:51:34  vdronov
 * *** empty log message ***
 *
 * Revision 1.28  2005/03/15 18:49:20  mju
 * Remincorrect comment.
 *
 * Revision 1.27  2005/02/17 17:56:31  vdronov
 * *** empty log message ***
 *
 * Revision 1.26  2004/12/01 20:20:48  vdronov
 * removed RAYCASTING and DENCETRIANGULATION algorithms
 *
 * Revision 1.25  2004/10/29 17:35:43  vdronov
 * changed controller
 *
 * Revision 1.24  2004/09/03 16:56:24  vdronov
 * *** empty log message ***
 *
 * Revision 1.23  2004/08/11 23:03:36  vdronov
 * *** empty log message ***
 *
 * Revision 1.22  2004/08/03 20:30:35  vdronov
 * *** empty log message ***
 *
 * Revision 1.21  2004/07/30 19:09:38  vdronov
 * *** empty log message ***
 *
 * Revision 1.20  2004/06/28 20:42:33  vdronov
 * *** empty log message ***
 *
 * Revision 1.19  2004/06/15 15:42:52  vdronov
 * added flat triangulation
 *
 * Revision 1.18  2004/03/05 17:01:43  mju
 * Use virtual dtor if class has virtual fns.
 *
 * Revision 1.17  2003/12/22 17:37:25  vdronov
 * Added PiecewiseTIN model
 *
 * Revision 1.16  2003/09/15 13:48:59  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.15  2003/08/26 15:34:35  vdronov
 * added VariableTriangulation
 *
 * Revision 1.14  2003/08/15 17:44:48  vdronov
 * nc.
 *
 * Revision 1.11  2003/07/30 14:20:45  mju
 * Check inclusion guards.
 * Ignore private section.
 * Standardize design.
 *
 * Revision 1.10  2003/05/28 19:31:18  vdronov
 * added dense ray casting
 *
 * Revision 1.7  2003/04/14 17:31:04  vdronov
 * added GetModel
 *
 * Revision 1.6  2003/04/09 19:12:43  vdronov
 * terrain null value
 *
 * Revision 1.5  2003/04/08 17:50:57  vdronov
 * changed triangulation structure
 *
 * Revision 1.1  2003/03/10 15:07:45  vdronov
 * Initial revision
 * \endif
**/ 

#ifndef  INC_GRE_3DTERRA_H
#define  INC_GRE_3DTERRA_H

#ifndef  INC_GRE_3DDC_H
#include <gre/3ddc.h>
#endif

#ifndef  INC_GRE_3DDC_H
#include <gre/3ddc.h>
#endif

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


#ifndef  INC_MI32_ASURFACE_H
#include <mi32/asurface.h>
#endif

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

#ifndef  INC_RVC_GEOREFER_H
#include <rvc/georefer.h>
#endif

namespace GRE {

#ifndef GENERATING_DOXYGEN_OUTPUT
class TEXTUREFILTER;
class TEXTURE;
class GEOMETRIC3D;
class CONTROLLER;
#endif // GENERATING_DOXYGEN_OUTPUT

//! Base class for 3D terrain models.
class TERRAIN {
   public:

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

#define  DECLARE_TERRAIN_IMPL_FACTORY(name,model)                    \
   class TERRAIN_IMPL_FACTORY_##name : public GRE::TERRAIN::IMPL_FACTORY { \
      public:                                         \
      TERRAIN_IMPL_FACTORY_##name (                            \
      ) { GRE::TERRAIN::Register(this,model); }             \
      virtual GRE::TERRAIN *v_ConstructImpl () {               \
      return (new GRE::name);                            \
         }                                         \
      };                                           \
   static TERRAIN_IMPL_FACTORY_##name s_TerrainImplFactory_##name;

      enum MODEL {
         MODEL_Default = 0,
         MODEL_TIN = 0,
         MODEL_VariableTriangulation = 1,
         MODEL_PiecewiseTIN = 2,
         MODEL_FlatTriangulation = 3,
         MODEL_Count = 4
         };

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

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

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

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

      virtual ~TERRAIN (                                 //! Constructor 
         );

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

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

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

      //! Create new instance of terrain model
      //!
      //! @return instance of texture model
      TERRAIN* CreateInstance () { return v_CreateInstance(); }

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

      //!   Is internal structures for terrain construction built? 
      //!
      //! @return true if built or false if an error
      bool IsBuilt (
         ) const { return m_Built; }

      //!   What rvc object type are supported in surface layer for this model (RVC::TIN or RVC::RASTER)
      //!
      //! @return true if built or false if an error
      bool IsObjectTypeSupported (
         const RVC::OBJTYPE objtype
         ) const { return v_IsObjectTypeSupported(objtype); }

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

      //!   GetDefaultScene initializes scene with default parameters for this model.
      //!
      //! @return >= 0 if initialization is done
      ERRVALUE GetDefaultScene ( 
         SCENE3D& scene
         ) { return v_GetDefaultScene(scene); }

      //!   Set scene for the model and array of textures to be drawn on it
      //!
      //! @return >= 0 if set is done
      ERRVALUE SetScene (
         const SCENE3D& scene,
         const SIMPLE_ARRAY<TEXTURE*> &textures
         ) { return v_SetScene(scene, textures); }

      //!   Draw given texture with given texture filter on this terrain with preset scene
      //!
      //! @return >= 0 if set is done
      ERRVALUE DrawScene (
         CONTROLLER &controller,        
         DRAWINGCONTEXT3D& drawing,
         TEXTURE* texture,
         TEXTUREFILTER* texturefilter
         ) { return v_DrawScene(controller, drawing, texture, texturefilter); }

      //!   Set scene for the model and array of geometrics to be drawn on it
      //!
      //! @return >= 0 if set is done
      ERRVALUE SetScene (
         const SCENE3D& scene,
         const SIMPLE_ARRAY<GEOMETRIC3D*> &geometrics,
         const bool wireframe
         ) { return v_SetScene(scene, geometrics, wireframe); }

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

      //! Get profile on elevation along polyline
      //!
      //! @return 0 or an error
      ERRVALUE ComputeProfile (
         const POLYLINE& polyline,
         POLYLINE& profile,
         SIMPLE_ARRAY<INT32>& index
         ) {return v_ComputeProfile(polyline, profile, index); }


      //! Get elevation at map projection coordinates (x, y)
      //!
      //! @return elevation in meters
      float GetElevation (
         const float x,
         const float y
         ) {return v_GetElevation(x,y); }

      //! Get angle to elevation at map projection coordinates (x, y)
      //!
      //! @return angle to north in radians
      float GetAngleToNorth (
         const float x,
         const float y
         ) const { return v_GetAngleToNorth(x, y); }

      //! Get abstract surface pointer
      //!
      //! @return pointer ot abstruct surface maybe 0
      const ABSTRACT_SURFACE* GetAbstractSurface (
         ) { return v_GetAbstractSurface(); }

      //! Has null areas
      //!
      //! @return true if has null areas
      bool HasNull (
         ) const { return v_HasNull(); }


      //! Is value at map projection coordinates (x, y) null
      //!
      //! @return true if value is null
      bool IsNull (
         const float x,
         const float y
         ) const { return v_IsNull(x,y); }

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

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

      void ClearBoundary (
         ) { 
         m_Boundary.Clear();
         return;
         };

      const REGION2D& GetBoundary (
         ) { 
         if (m_Boundary.IsEmpty()) v_CreateBoundary(m_Boundary); 
         return m_Boundary;
         };

      bool IsBoundaryChanged (
         ) const { 
         return m_Boundary.IsEmpty();
         };

      bool IsTerrainDynamic (
         ) const { 
         return false;
         };

      POINTSFIELD& GetPointsField (
         ) { 
         return m_PointsField;
         };

   protected:

      TERRAIN (                                 //! Constructor 
         const char* name,
         const char* desc,
         const MODEL model
         );

      //!   Set built state.
      void SetBuilt (
         const bool built
         ) {m_Built = built; }

   private:

      #ifndef GENERATING_DOXYGEN_OUTPUT

      static IMPL_FACTORY* s_ImplFactories[MODEL_Count];

      const char* m_Name;
      const char* m_Description;
      const MODEL m_Model;
      bool m_Built;                                //!<  Is an object built?

      GRE::POINTSFIELD m_PointsField;
      REGION2D m_Boundary;

      TERRAIN (                                 //! Constructor 
         );

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

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

      #endif //!< GENERATING_DOXYGEN_OUTPUT

      virtual TERRAIN* v_CreateInstance (
         ) = 0;

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

      virtual bool v_IsObjectTypeSupported (
         const RVC::OBJTYPE objtype
         ) const = 0;

      virtual void v_Free (
         ) = 0;

      virtual ERRVALUE v_GetDefaultScene ( 
         SCENE3D& scene
         ) const = 0;

      virtual ERRVALUE v_SetScene (
         const SCENE3D& scene,
         const SIMPLE_ARRAY<TEXTURE*> &textures
         ) = 0;

      virtual ERRVALUE v_DrawScene (
         CONTROLLER &controller,        
         DRAWINGCONTEXT3D& drawing,
         TEXTURE* texture,
         TEXTUREFILTER* texturefilter
         ) = 0;

      virtual ERRVALUE v_SetScene (
         const SCENE3D& scene,
         const SIMPLE_ARRAY<GEOMETRIC3D*> &geometrics,
         const bool wireframe
         ) = 0;

      virtual const DRECT3D& v_GetExtents (
         ) = 0;

      virtual void v_CreateBoundary (
         REGION2D& boundary
         ) = 0;

      virtual float v_GetElevation (
         const float x,
         const float y
         ) const = 0;

      virtual ERRVALUE v_ComputeProfile (
         const POLYLINE& polyline,
         POLYLINE& profile,
         SIMPLE_ARRAY<INT32>& index
         ) = 0;

      virtual float v_GetAngleToNorth (
         const float x,
         const float y
         ) const = 0;

      virtual const ABSTRACT_SURFACE* v_GetAbstractSurface (
         ) = 0;

      virtual bool v_HasNull (
         ) const  = 0;

      virtual bool v_IsNull (
         const float x,
         const float y
         ) const  = 0;

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

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


//! Base class for 3D terrain controller.
//! This class is designed for buffering of terrain constructions 
class CONTROLLER {
   public:

      //! Called by terrain model on begining of terrain constuctions
      void OnBegin () { v_OnBegin(); }

      //! Called by terrain model on ending of terrain constuctions
      void OnEnd () { v_OnEnd(); }

      //! Called by terrain model on full(partial) triangulation
      void OnTriangulation (  
         DRAWINGCONTEXT3D& drawing,
         const TRIANGULATION& triangulation
         ) { v_OnTriangulation(drawing, triangulation); }

      //! Called by terrain model on full(partial) pixalization
      void OnPixalization (   
         DRAWINGCONTEXT3D& drawing,
         const PIXALIZATION& pixalization
         ) { v_OnPixalization(drawing, pixalization); }

   protected:

      CONTROLLER () {}

      virtual ~CONTROLLER () {}

   private:

      virtual void v_OnBegin (
         ) = 0;

      virtual void v_OnEnd (  
         ) { }

      virtual void v_OnTriangulation (    
         DRAWINGCONTEXT3D& drawing,
         const TRIANGULATION& triangulation
         ) = 0;

      virtual void v_OnPixalization (  
         DRAWINGCONTEXT3D& drawing,
         const PIXALIZATION& pixalization
         ) = 0;

   };


//! Simple implementation of 3D terrain controller.
class SIMPLECONTROLLER : public GRE::CONTROLLER {
   public:
      virtual ~SIMPLECONTROLLER () {}

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      GRE::TRIANGULATIONVECTOR m_Triangulations;
      GRE::PIXALIZATIONVECTOR m_Pixalizations;

      void v_OnBegin (
         );

      void v_OnEnd (    
         );

      void v_OnTriangulation (   
         DRAWINGCONTEXT3D& drawing,
         const GRE::TRIANGULATION& triangulation
         );

      void v_OnPixalization (    
         DRAWINGCONTEXT3D& drawing,
         const GRE::PIXALIZATION& pixalization
         );

      #endif //!< GENERATING_DOXYGEN_OUTPUT
   };

}     //! End of namespace

#endif

---