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.19 2005/10/05 15:49:02 mju Exp $
 *
 * $Log: 3dvtter.h_v $
 * Revision 1.19  2005/10/05 15:49:02  mju
 * Include gre base hdr.
 *
 * Revision 1.18  2005/08/19 15:12:52  vdronov
 * rollback to 1.16
 *
 * Revision 1.17  2005/08/17 20:14:25  vdronov
 * added static MakeSurfaceProperties.
 *
 * Revision 1.16  2005/06/27 17:12:30  vdronov
 * added nulmask handling
 *
 * Revision 1.15  2005/06/17 17:05:35  vdronov
 * added savings optimization structure
 *
 * Revision 1.14  2005/03/31 23:50:02  vdronov
 * *** empty log message ***
 *
 * Revision 1.13  2005/02/17 17:57:43  vdronov
 * *** empty log message ***
 *
 * Revision 1.12  2005/01/12 23:01:05  vdronov
 * added some modifications fot data structure
 *
 * Revision 1.11  2004/12/23 15:52:41  vdronov
 * nc
 *
 * Revision 1.10  2004/12/22 23:45:29  vdronov
 * replaced plainar properties by pyramid properties
 *
 * Revision 1.9  2004/12/10 22:35:18  vdronov
 * added ErrorTolerance
 *
 * Revision 1.8  2004/12/01 18:42:09  vdronov
 * ALIGN
 *
 * 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_BASE_H
#include <gre/base.h>
#endif

#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

#ifndef  INC_RVC_NULLMASK_H
#include <rvc/nullmask.h>
#endif

#include <map>

namespace GRE {

class VARIABLETRIANGULATION : public TERRAIN {
   public:

      VARIABLETRIANGULATION (                               // Constructor 
         );

      ~VARIABLETRIANGULATION (                              // Destructor 
         );

      void SetErrorTolerance (
         double tolerance
         ) { m_ErrorTolerance = bound(tolerance, 0.5, 10.0); return; };

      double GetErrorTolerance (
         ) const { return m_ErrorTolerance; };

      ERRVALUE SaveSurfaceProperties (
         );

      bool CanSaveSurfaceProperties (
         );

      bool HasSurfaceProperties (
         );

   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_Elevation;      // Important to have it as first member
         float m_Error;
         float m_Radius;

         PROPERTY () : m_Elevation(-1.0F), m_Error(-1.0F), m_Radius(-1.0F) {};
         PROPERTY (const float elevation, const float error, const float radius) : 
            m_Elevation(elevation), m_Error(error), m_Radius(radius) {};
         };

      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];

      GRE_LAYER_SURFACE* m_Layer;
      ABSTRACT_SURFACE *m_Surface;
      DRECT3D ALIGN16(m_Extents);
      SPATREF::COORDREFSYS m_CoordRefSys;
      TRANS2D_MAPGEN m_Transformation;
      bool m_AreSurfacePropertiesCreated;
      bool m_IsCreatedInside;

      RVC::RASTER m_DEM;
      SIMPLE_ARRAY<INT32> m_Index;
      double ALIGN8(m_ZDefaults[3][3]);

      bool m_Parity;
      double ALIGN8(m_Value);
      double ALIGN8(m_ErrorTolerance);
      DPOINT3D ALIGN16(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;
      INT32 m_XSize;
      INT32 m_YSize;
      BITSET m_BlockBits;  
      DOUBLE_ARRAY<DRECT3D> m_BlockExtents;

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

      double ALIGN8(m_DataScale);
      double ALIGN8(m_Scale);
      double ALIGN8(m_ScaleSqrt2);
      double ALIGN8(m_ZMin);
      double ALIGN8(m_ZMax);
      double ALIGN8(m_ZDefault);

      RVC::OBJECT m_File;
      RVC::NULLMASK m_NullMask;
      RVC::RASTER m_Corners;
      SIMPLE_ARRAY<RVC::RASTER*> m_WhiteH;
      SIMPLE_ARRAY<RVC::RASTER*> m_HBlackH;
      SIMPLE_ARRAY<RVC::RASTER*> m_VBlackH;
      SIMPLE_ARRAY<RVC::RASTER*> m_WhiteE;
      SIMPLE_ARRAY<RVC::RASTER*> m_HBlackE;
      SIMPLE_ARRAY<RVC::RASTER*> m_VBlackE;
      SIMPLE_ARRAY<RVC::RASTER*> m_WhiteR;
      SIMPLE_ARRAY<RVC::RASTER*> m_HBlackR;
      SIMPLE_ARRAY<RVC::RASTER*> m_VBlackR;
      INT32 m_LevelSize;
      INT32 m_LevelMask;
      SIMPLE_ARRAY<UINT8> m_LevelIndex;
      RVC::OBJECT m_ComputedSetFile;
      RVC::RASTER m_ComputedSetRaster;
      
      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
         );

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

      // 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 true; };   //to check boundary condition

      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 SetSceneForBlocks (
         const SCENE3D& scene,
         const SIMPLE_ARRAY<GEOMETRIC3D*> &geometrics,
         const bool wireframe
         );

      ERRVALUE DrawSceneForBlocks (
         CONTROLLER &controller,        
         DRAWINGCONTEXT3D& drawing,
         TEXTURE* texture,
         TEXTUREFILTER* texturefilter,
         const DRAW3DMODE draw3Dmode = DRAW3DMODE_Texture
         );

      void TransformBlocks (
         const TRANS2D_MAPGEN& transformation
         );

      ERRVALUE DefineSurfaceProperties (
         );

      ERRVALUE MakeSurfaceProperties (
         RVC::OBJECT& parent
         );

      ERRVALUE CalculateSurfaceProperties (
         );

      bool OpenSurfaceProperties (
         );

      ERRVALUE CloseSurfaceProperties (
         );

      bool CheckAndOpenSurfaceProperties (
         RVC::RASTER& corners
         );

      ERRVALUE DeleteSurfaceProperties (
         );

      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 SetSurfaceProperty (
         const INT32 x,
         const INT32 y,
         PROPERTY& property
         );

      void GetSurfaceProperty (
         const INT32 x,
         const INT32 y,
         PROPERTY& property,
         const bool geth,
         const bool gete,
         const bool getr
         );

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

      void SetPropertyComputed (
         const INT32 x,
         const INT32 y
         );

      ERRVALUE MakeComputedSet (
         );

      void DestroyComputedSet (
         );

      double GetSurfaceElevation (
         const INT32 x,
         const INT32 y
         );

      #endif // GENERATING_DOXYGEN_OUTPUT
   };

};    // End of namespace

#endif

---