3dvtter.h

Go to the documentation of this file.

/**
 * \file gre/3dlpter.h 
 * \brief Implementation of terrain algorithm
 *
 * \if NODOC
 * $Id: 3dvtter.h_v 1.7 2004/09/03 16:57:03 vdronov Exp $
 *
 * $Log: 3dvtter.h_v $
 * Revision 1.7  2004/09/03 16:57:03  vdronov
 * *** empty log message ***
 *
 * Revision 1.6  2004/08/11 23:04:55  vdronov
 * *** empty log message ***
 *
 * Revision 1.5  2004/07/30 19:09:01  vdronov
 * *** empty log message ***
 *
 * Revision 1.4  2004/06/29 15:22:58  vdronov
 * *** empty log message ***
 *
 * Revision 1.3  2003/10/02 16:18:21  linux32build!build
 * Doxygen
 *
 * Revision 1.2  2003/09/26 17:19:26  vdronov
 * added core algorithm
 *
 * Revision 1.1  2003/08/26 15:33:25  vdronov
 * Initial revision
 * \endif
 *
**/ 

#ifndef  INC_GRE_3DLPTER_H
#define  INC_GRE_3DLPTER_H

#ifndef  INC_GRE_3DTERRA_H
#include <gre/3dterra.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_OBJECT_H
#include <rvc/object.h>
#endif

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

#include <map>

namespace GRE {

class VARIABLETRIANGULATION : public TERRAIN {
   public:

      VARIABLETRIANGULATION (                               // Constructor 
         );

      ~VARIABLETRIANGULATION (                              // Destructor 
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      enum DIRECTION {
         DIRECTION_N  = 0,
         DIRECTION_NE = 1,
         DIRECTION_E  = 2,
         DIRECTION_SE = 3,
         DIRECTION_S  = 4,
         DIRECTION_SW = 5,
         DIRECTION_W  = 6,
         DIRECTION_NW = 7,
         DIRECTION_Count = 8
         };

      typedef std::map<INT32, DPOINT3D> VERTEXMAP; 

      struct PROPERTY {
         FLOAT m_Error;
         FLOAT m_Radius;

         PROPERTY () : m_Error(-1.0F), m_Radius(-1.0F) {};
         PROPERTY (const float error, const float radius) : m_Error(error), m_Radius(radius) {};
         bool IsSet () const { return (m_Error != -1.0F); };
         };


      struct BLOCK {

         DRECT3D m_Extents;
         double m_Elevation;
         float m_Error;
         float m_Radius;

         BLOCK () : m_Elevation(0.0) {};
         };

      static const bool s_Parity[DIRECTION_Count];
      static const INT32 s_SX[DIRECTION_Count];
      static const INT32 s_SY[DIRECTION_Count];
      static const DIRECTION s_DirectionL[DIRECTION_Count];
      static const DIRECTION s_DirectionR[DIRECTION_Count];
      static const INT32 s_MX[DIRECTION_Count];
      static const INT32 s_MY[DIRECTION_Count];

      ABSTRACT_SURFACE *m_Surface;
      DRECT3D m_Extents;
      SPATREF::COORDREFSYS m_CoordRefSys;
      TRANS2D_MAPGEN m_Transformation;

      RVC::RASTER m_DEM;
      RVC::OBJECT m_File;
      RVC::RASTER m_Error;
      RVC::RASTER m_Radius;
      DOUBLE_ARRAY<double> m_BlockDEM;
      SIMPLE_ARRAY<float> m_BlockError;
      SIMPLE_ARRAY<float> m_BlockRadius;
      SIMPLE_ARRAY<INT32> m_Index;
      double m_ZDefaults[3][3];

      bool m_Parity;
      double m_Value;
      DPOINT3D m_Viewer;

      INT32 m_BlockSize;
      INT32 m_HalfBlockSize;
      INT32 m_BlockSizePlus;
      INT32 m_BlockCells;
      INT32 m_BlockColumn;
      INT32 m_BlockLine;
      INT32 m_NumBlocks;
      INT32 m_XBlocks;
      INT32 m_YBlocks;
      BITSET m_BlockBits;  
      DOUBLE_ARRAY<BLOCK> m_Blocks;

      INT32 m_XLNodes;
      INT32 m_YLNodes;
      INT32 m_NumLNodes;
      DOUBLE_ARRAY<double> m_LevelDEM;

      VERTEXMAP m_VertexMap;
      TRIANGULATION m_Triangulation;
      SCENE3D *m_Scene;
      CONTROLLER *m_Controller;
      DRAWINGCONTEXT3D *m_Drawing;

      double m_Scale;
      double m_ScaleSqrt2;
      double m_ZMin;
      double m_ZMax;
      double m_ZDefault;
      bool m_HasNullValue;
      double m_NullValue;

      STATUSCONTEXT* m_StatusContext;

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

      static void GetCorners (
         const DRECT3D& rect,
         DPOINT3D points[8]
         );

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

      // Build internal structures for terrain decimation 
      //
      // @return 0 if OKey or < 0 if an error
      ERRVALUE v_Build (
         const GRE_LAYER *layer
         );

      bool v_IsObjectTypeSupported (
         const RVC::OBJTYPE objtype
         ) const { return (objtype == RVC::OBJTYPE_Raster); };

      // Free internal structures for terrain decimation 
      //
      // @return none
      void v_Free (
         );

      ERRVALUE Create (              
         const GRE_LAYER *layer
         );

      void Delete (               
         );

      ERRVALUE v_GetDefaultScene ( 
         SCENE3D& scene
         ) const;

      // Set scene by viewer and center positions and angle of field of view.
      //
      // @return none
      ERRVALUE v_SetScene (
         const SCENE3D& scene,
         const SIMPLE_ARRAY<TEXTURE*> &textures   
         );

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

      // Get elevation at model coordinates (x, y)
      float v_GetElevation (
         const float x,
         const float y
         ) const;

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

      // Get angle to elevation at model coordinates (x, y)
      float v_GetAngleToNorth (
         const float x,
         const float y
         ) const;

      const ABSTRACT_SURFACE* v_GetAbstractSurface (
         ) { return m_Surface; }

      bool v_HasNull (
         ) const { return m_HasNullValue; };

      bool v_IsNull (
         const float x,
         const float y
         ) const;

      void v_SetCoordRefSys (
         const SPATREF::COORDREFSYS& CoordRefSys
         );

      const SPATREF::COORDREFSYS v_GetCoordRefSys (
         ) const { return m_CoordRefSys; };

      const DRECT3D& v_GetExtents (
         ) { return m_Extents; };

      void v_CreateBoundary (
         REGION2D& boundary
         );

      ERRVALUE CreateBlocks (
         const TRANS2D_MAPGEN& transformation
         );

      void DeleteBlocks (
         );

      bool IsBlockValid (
         const INT32 column,
         const INT32 line
         ) {return ((0 <= column) && (column < m_XBlocks) && (0 <= line) && (line < m_YBlocks)); };

      ERRVALUE SetSceneForBlocks (
         const SCENE3D& scene,
         const SIMPLE_ARRAY<TEXTURE*> &textures   
         );

      ERRVALUE DrawSceneForBlocks (
         CONTROLLER &controller,        
         DRAWINGCONTEXT3D& drawing,
         TEXTURE* texture,
         TEXTUREFILTER* texturefilter
         );

      void TransformBlocks (
         const TRANS2D_MAPGEN& transformation
         );

      ERRVALUE MakePropertyRasters (
         );


      ERRVALUE CalculatePropertyRasters (
         );


      ERRVALUE ReadDataBlock (
         const INT32 index
         );

      void CalculateZDefaults (
         const INT32 index
         );

      double GetZDefault (
         const INT32 column,
         const INT32 line
         );

      double CalculateZDefault (
         const INT32 column,
         const INT32 line
         );

      ERRVALUE CalculateProperty (
         const INT32 x,
         const INT32 y,
         const INT32 length,
         const DIRECTION direction,
         PROPERTY& property
         );

      FLOAT CalculateError (
         const INT32 x,
         const INT32 y,
         const INT32 length,
         const DIRECTION direction
         );

      FLOAT CalculateRadius (
         const INT32 x,
         const INT32 y,
         const INT32 length,
         const DIRECTION direction
         );

      ERRVALUE SubMeshRefine (
         const INT32 px,
         const INT32 py,
         const INT32 length,
         const DIRECTION direction,
         const INT32 level
         );

      ERRVALUE VertexAppend (
         const INT32 x,
         const INT32 y,
         const bool parity
         );

      bool IsVertexActive (
         const INT32 x,
         const INT32 y
         );

      void MakeVertex (
         const INT32 x,
         const INT32 y,
         const INT32 index,
         DPOINT3D& point
         );


      INT32 CalculateIndex (
         const INT32 x,
         const INT32 y
         );

      void GetBlockProperty (
         const INT32 index,
         PROPERTY& property
         );

      float GetBlockError (
         const INT32 index
         );

      float GetBlockRadius (
         const INT32 index
         );

      double GetBlockElevation (
         const INT32 index
         );

      void SetRasterProperty (
         const INT32 x,
         const INT32 y,
         PROPERTY& property
         );

      void GetRasterProperty (
         const INT32 x,
         const INT32 y,
         PROPERTY& property
         );

      double GetRasterElevation (
         const INT32 x,
         const INT32 y,
         const bool check = true
         );

      #endif // GENERATING_DOXYGEN_OUTPUT
   };

};    // End of namespace

#endif

---