gre/3dvtter.h

Go to the documentation of this file.

#ifndef  INC_GRE_3DLPTER_H
#define  INC_GRE_3DLPTER_H

#ifndef  INC_GRE_3DTERRA_H
#include <gre/3dterra.h>
#endif

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

#ifndef  INC_MAP
#include <map>
#define  INC_MAP
#endif


namespace GRE {

class VARIABLETRIANGULATION : public TERRAIN {
   public:

      VARIABLETRIANGULATION ();

      virtual ~VARIABLETRIANGULATION ();

      bool CanSaveSurfaceProperties () const;

      double GetErrorTolerance () const
         { return m_ErrorTolerance; };

      bool HasSurfaceProperties () const
         { return (IsBuilt() && m_AreSurfacePropertiesCreated && m_IsCreatedInside); }

      ERRVALUE SaveSurfaceProperties ();

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

   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;
      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 (
         );

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

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

      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

---