3dutils.h

Go to the documentation of this file.

/*** 
 * \file 3dutils.h <gre/3dutils.h>
 * \brief supporting structures
 *
 * \if NODOC
 * $Id: 3dutils.h_v 1.11 2004/08/11 23:04:31 vdronov Exp $
 *
 * $Log: 3dutils.h_v $
 * Revision 1.11  2004/08/11 23:04:31  vdronov
 * *** empty log message ***
 *
 * Revision 1.10  2004/07/30 22:01:50  vdronov
 * added DRAW3DMODE
 *
 * Revision 1.9  2003/09/15 13:48:59  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.8  2003/08/15 20:01:58  vdronov
 * add docs.
 *
 * Revision 1.7  2003/07/30 14:42:18  mju
 * Check inclusion guards.
 * Ignore private sections.
 *
 * Revision 1.5  2003/04/22 19:52:02  vdronov
 * added pixalization
 *
 * Revision 1.2  2003/04/08 17:50:23  vdronov
 * changed triangulation structure
 *
 * Revision 1.1  2003/03/10 15:08:51  vdronov
 * Initial revision
 * \endif
 */ 

#ifndef  INC_GRE_3DUTILS_H
#define  INC_GRE_3DUTILS_H

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

#ifndef  INC_MI32_BITSET_H
#include <mi32/bitset.h>
#endif

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

#ifndef  INC_MI32_DOUBLEAR_H
#include <mi32/doublear.h>
#endif

#ifndef _VECTOR_
#include <vector>
#endif

namespace GRE {

#ifndef GENERATING_DOXYGEN_OUTPUT
class TERRAIN;
class TEXTURE;
class TEXTUREFILTER;
#endif //!< GENERATING_DOXYGEN_OUTPUT

enum DRAW3DMODE {
   DRAW3DMODE_Texture = 0,
   DRAW3DMODE_Color = 1,
   DRAW3DMODE_Wireframe = 2
   };

enum TRIANGLEMODE {
   TRIANGLEMODE_List = 0,
   TRIANGLEMODE_Fan = 1,
   TRIANGLEMODE_Strip = 2,
   TRIANGLEMODE_TIN = 3
   };

struct TRIANGLEINDEX {
   INT32 vertex1;
   INT32 vertex2;
   INT32 vertex3;
   };

struct EDGEINDEX {
   INT32 vertexfrom;
   INT32 vertexto;
   };

struct INDEX {
   INT32 index;
   };

struct TRIANGULATION {

   TRIANGLEMODE m_Mode;

   SIMPLE_ARRAY<FPOINT3D> m_Vertices;
   SIMPLE_ARRAY<INDEX> m_Indices;
   SIMPLE_ARRAY<EDGEINDEX> m_Edges;                //!< used in TRIANGLEMODE_TIN
   SIMPLE_ARRAY<TRIANGLEINDEX> m_Triangles;        //!<  used in TRIANGLEMODE_TIN
   BITSET m_EdgesBits;                             //!<  used in TRIANGLEMODE_TIN
   BITSET m_TrianglesBits;                         //!<  used in TRIANGLEMODE_TIN

   DRAW3DMODE m_Draw3DMode;

   TERRAIN *m_Terrain;
   TEXTURE *m_Texture;
   TEXTUREFILTER *m_TextureFilter;

   COLOR m_Color;

   TRIANGULATION (
      ) :
      m_Mode(TRIANGLEMODE_List),
      m_Draw3DMode(DRAW3DMODE_Texture),
      m_Terrain(0),
      m_Texture(0),
      m_TextureFilter(0)
      {
      };

   ~TRIANGULATION (
      ) {
      };

   };

typedef std::vector<const TRIANGULATION*> TRIANGULATIONVECTOR; 

struct PIXALIZATION {

   SIMPLE_ARRAY<LPOINT2D> m_Pixels;
   DOUBLE_ARRAY<DPOINT3D> m_Points;
   DOUBLE_ARRAY<DPOINT3D> m_Points0;
   DOUBLE_ARRAY<DPOINT3D> m_Points1;
   DOUBLE_ARRAY<DPOINT3D> m_Points2;

   TERRAIN *m_Terrain;
   TEXTURE *m_Texture;
   TEXTUREFILTER *m_TextureFilter;

   PIXALIZATION (
      ) :
      m_Terrain(0),
      m_Texture(0),
      m_TextureFilter(0)
      {
      };

   ~PIXALIZATION (
      ) {
      };

   };

typedef std::vector<const PIXALIZATION*> PIXALIZATIONVECTOR; 

//! SCREENPLANE class describes plane in screen space in homogenius coordinates.
class SCREENPLANE {

public:

   SCREENPLANE (                                //! Constructor 
      ) : 
      m_IsSet(false),
      m_DX(0.0), 
      m_DY(0.0), 
      m_DW(1.0) 
      {};

   ~SCREENPLANE (                               //! Destructor 
      ) {};

   //! Clear plane parameters
   void Clear (
      ) { m_IsSet = false; return;};

   //! Is plane set
   //! 
   //! @return true if plane is set
   bool IsSet (
      ) const { return m_IsSet; };

   //! Set plane by three points in homogenius coordinates.
   void Set (
      const DPOINT3DH& pt1, 
      const DPOINT3DH& pt2, 
      const DPOINT3DH& pt3
      );

   //! Get point on screen plane that projected to screen at center of screen pixel with coordinates (column, line)
   //! 
   //! @return true if point exists
   bool GetPoint (
      const INT32 line,
      const INT32 column,
      DPOINT3DH& point
      );

   //! Get extents on screen plane that projected to screen at screen pixel with coordinates (column, line)
   //! 
   //! @return true if extents exist
   bool GetCellExtents (
      const INT32 line,
      const INT32 column,
      DPOINT3DH hpoints[4]
      );

private:
   #ifndef GENERATING_DOXYGEN_OUTPUT

   bool m_IsSet;
   double m_DX; 
   double m_DY; 
   double m_DW; 
   double m_DL;
   double m_DXZ;
   double m_DYZ;
   double m_DWZ;

   #endif //!< GENERATING_DOXYGEN_OUTPUT
   };


//! UTILS3D class contains supportive static methods
class UTILS3D {
   public:

      enum CELLTRACE {
         CELLTRACE_Edge,
         CELLTRACE_Center
         };

      struct COMPONENT {
         RVC::RASTER* m_Raster;
         RVC::IMAGE::CONVMODE m_Convert;
         bool m_HasNullValue;
         ANYRASTVALUE m_NullValue;
         UINT8 m_BytesPerCell;

         COMPONENT ();

         ~COMPONENT () {};

         };

      static UINT8 log2i (
         const UINT32 value,
         const bool up = true
         );

      static ERRVALUE CreateBoundaryRegionFromRaster (
         GRE::UTILS3D::COMPONENT* components,
         INT32 numComponents,
         RVC::RASTER& mask,
         REGION2D& region,
         const CELLTRACE celltrace
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      UTILS3D ();
      ~UTILS3D ();

      #endif //!< GENERATING_DOXYGEN_OUTPUT
   };


};    //! End of namespace

#endif

---