gridPstLst.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1999 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: gridPstLst.h,v $ $Revision: 1.9 $ $State: Exp $
*********************************************************************/

#ifndef gridPstLst_H_
#define gridPstLst_H_

// include files
#include "gdb/gdbDefines.h"
#include "gdb/baseVtxLst.h"
#include "geometry/point.h"
#include "gdb/surfMgr.h"

typedef enum
{

  SW_NE_DIAGONAL,
  NW_SE_DIAGONAL

} DtGridDiagonalType;


// forward declarations
class DtSurface;
class DtSurfaceManager;
class DtGroup;
class DtVertexManager;


//
// class DtGridPostList:
//
// DtGridPostList is used to describe the terrain skin.
// Posts are uniformly spaced in the x and y directions.
// Diagonalization at posts runs southwest to northeast,
// or southeast to northwest. However, the convention is
// uniform for the entire database.
// At each post, the elevation of the terrain is 
// specified. Also defined are the characterization of surfaces
// of the two triangles in the square that is to the NE of the
// post. The last row and the last column have no surface
// associations. They do have corresponding elevation data.
//
class DT_DLL_gdb DtGridPostList : public DtBaseVertexList
{
public:

   // default constructor
   DtGridPostList();

   // destructor
   virtual ~DtGridPostList();

   // additional constructor that specifies the origin of the grid
   // post list, associated surface manager, post interval, width and
   // height of the grid post list measured in posts, and the 
   // diagonalization of the database.
   DtGridPostList(DtSurfaceManager* surfaceManager,
                  const DtPoint o,
                  double interval, 
                  unsigned int pwide, 
                  unsigned int phigh,
                  bool swNeDiag);

   // copy constructor
   DtGridPostList(const DtGridPostList& orig);

   // assignment operator
   DtGridPostList& operator=(const DtGridPostList& orig);

   // return the type of the node.
   virtual DtGdbNode::DtGdbNodeType type() const;

   //accessor functions

   // returns origin of grid post list
   virtual const DtPoint& origin() const;

   // returns number of posts along x-axis
   virtual unsigned int width() const;

   // returns number of posts along y-axis
   virtual unsigned int height() const;

   // returns distance between adjacent posts in x- or y- direction.
   virtual double interval() const;

   // a grid post list may be diagonalized SW-NE or SE_NW. Returns the
   // diagonalization associated with this grid post list.
   virtual DtGridDiagonalType diagonal() const;

   // used to set the diagonal from the value read from
   // a GDB1.0 Grid Node; generally, it should not be used!
   virtual void setDiagonal(bool diag);

   // returns array of elevations associated with the grid post list
   virtual double* elevations() const;

   // returns a pointer to the surface manager associated with the grid post list
   virtual DtSurfaceManager* surfaces() const;

   // sets the surface list associated with the grid post list
   virtual void setSurfaceManager(DtSurfaceManager* surfMgr);

   // returns index into surface list associated with triangle 0 (top-left
   // for SW-NE, bottom-left for SE_NW) for post n.
   virtual unsigned int tri0Surface(unsigned int n) const;

   // returns index into surface list associated with triangle 1 (bottom-right
   // for SW-NE, top-right for SE_NW) for post n.
   virtual unsigned int tri1Surface(unsigned int n) const;

   // get the i-th vertex of gridpost list  
   virtual DtPoint vertex(unsigned int i) const;

   // return the i-th vertex of gridpost list in retVal
   virtual bool getVertex(DtPoint& retVal, unsigned int i) const;

   //access the surface description of Triangle0(SW)? at postnum.   
   virtual DtSurface& getTri0Surface(unsigned int postnum) const;

   //access the surface description of Triangle1(NE)? at postnum.
   virtual DtSurface& getTri1Surface(unsigned int postnum) const;

   // This function is used when elevations are specified sequentially.
   // when you add a grid post, should you specify elevation and
   // and surface indices for the next post?? -- RVK
   virtual unsigned int addGridPost(double elevation);

   // set the elevation at postnum as specified.
   virtual void setElevation(unsigned int postnum, double elevation);

   // set the surface  of Triangle0(top-left for SW-NE diagonal, bottom-left
   // for SE-NW diagonal) at postnum.
   virtual void setTri0Surface(unsigned int postnum, DtSurfaceID surfaceID, bool check = true);

   // set the surface  of Triangle1(bottom-right if SW-NE diagonal, top-right
   // for SE-NW diagonal) at postnum.
   virtual void setTri1Surface(unsigned int postnum, DtSurfaceID surfaceID, bool check = true);

   // determines if postNum is the last grid post of a row
   virtual bool isLastGridpostOfRow(unsigned int pnum) const;

   // determines if postNum is the last grid post of a column
   virtual bool isLastGridpostOfColumn(unsigned int pnum) const;

   // Triangulates the gridpostlist returning 2 * (height - 1) * (width - 1) 
   // triangles as children of the specified group.
   // Needs the terrain database for vertex manager and surface manager pointers 
   // Uses the specified vertex manager and sets the triangles to reference
   // the same SurfaceManager that this class references.
   // Returns false if triangulation failed for any reason.
   virtual bool triangulate(DtGroup& parent, DtTerrainDatabase* terrainDatabase) const;

   //debugging aid function
   virtual void dump(int indentLevel) const;

   virtual int sizeInBytes() const;

protected:

   virtual unsigned int* tri0Surfaces() const;
   virtual unsigned int* tri1Surfaces() const;

protected:

   DtPoint      myOrigin;
   unsigned int myWidthInPosts;
   unsigned int myHeightInPosts;
   double       myPostInterval;
   bool         mySwNeDiag;

   // Dynamically allocated array of elevations.  
   double*     myElevationList;   

   // my list of surfaces
   mutable DtSurfaceManager* mySurfaceManager; 

   // Dynamically allocated array of surface indices for 
   // left triangle
   unsigned int* myTri0Surfaces;
   
   // Dynamically allocated array of surface indices for 
   // triangle to the right.
   unsigned int* myTri1Surfaces; 
};



inline DtGdbNode::DtGdbNodeType DtGridPostList::type() const
{
   return(DtGdbNode::GRIDPOST_LIST);
}

inline const DtPoint& DtGridPostList::origin() const
{
   return myOrigin;
}

inline unsigned int DtGridPostList::width() const
{
   return myWidthInPosts;
}

inline unsigned int DtGridPostList::height() const
{
   return myHeightInPosts;
}

inline double DtGridPostList::interval() const
{
   return myPostInterval;
}

inline DtGridDiagonalType DtGridPostList::diagonal() const
{
   if (mySwNeDiag)
      return(SW_NE_DIAGONAL);
   else
      return(NW_SE_DIAGONAL);
}

inline void DtGridPostList::setDiagonal(bool diag)
{
   mySwNeDiag = diag;
}

inline double* DtGridPostList::elevations() const
{
   return myElevationList;
}

inline DtSurfaceManager* DtGridPostList::surfaces() const
{
   return mySurfaceManager;
}

inline void DtGridPostList::setSurfaceManager(DtSurfaceManager* surfMgr)
{
   mySurfaceManager = surfMgr;
}

inline unsigned int* DtGridPostList::tri0Surfaces() const
{
   return myTri0Surfaces;
}

inline unsigned int* DtGridPostList::tri1Surfaces() const
{
   return myTri1Surfaces;
}

#endif