include/gdb/grid.h

Go to the documentation of this file.

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

#ifndef grid_H_
#define grid_H_

// include files
#include "gdb/gdbDefines.h"
#include "gdb/gdbNode.h"

#include "geometry/point.h"
#include "geometry/tdbextent.h"
#include "gdb/surfMgr.h"

// forward declarations
class DtGridPostList;
class DtSurface;
class DtTriangleIndirect;
 

//
//
// class DtGrid:
//
// DtGrid is used to represent a section of the terrain using
// elevations and soiltypes in a grid. This is used to import
// ctdb databases that combine patches that are gridded with
// those that are TINned.
//
//
class DT_DLL_gdb DtGrid : public DtGdbNode
{
public:

   // default constructor
   DtGrid();

   // additional constructor
   DtGrid(DtGridPostList* gplist,
          int nwide, 
          int nhigh, 
          int startGpIndex,
          DtTerrainDatabase* terrainDatabase);

   // destructor
   virtual ~DtGrid();

   // initialize object parameters
   virtual void init(DtGridPostList* gplist, 
                     int nwide, 
                     int nhigh, 
                     int startGpIndex,
                     DtTerrainDatabase* terrainDatabase);

   // returns type of gdb node
   virtual DtGdbNode::DtGdbNodeType type() const;

   //returns the width of the grid measured in number of posts.
   virtual int width() const;

   //returns the height of the grid measured in number of posts.
   virtual int height() const;

   // returns the starting post index of the grid with reference to its
   // grid post list.
   virtual int startingGridPostIndex() const;

   //returns pointer to gridpost list associated with the grid.
   virtual DtGridPostList* gridPostList() const;

   // returns the number of posts on this grid
   virtual  int numberOfPosts() const;

   // returns the extent of the grid in 3-dimensions
   virtual const DtExtent& extent() const;

   // given the post number on this grid, return the corresponding
   // post number in the associated grid post list.
   virtual  int gridPostIndex(int postIndex) const;

   // returns the index in the grid post list that corresponds
   // to a post col intervals to the East, and row intervals to the
   // North from the starting post on this grid.
   virtual int gridPostIndex(int col, int row) const;

   // return the bottom left vertex of grid
   virtual const DtVertex& bottomLeftVertex() const;

   // return the top right vertex of grid
   virtual const DtVertex& topRightVertex() const;

   // process the polygons included in the node that fall within the input
   // extent, and update the color count in the colorCountRecord which is
   // an in-out parameter.
   virtual void countPolyColors(DtColorCountRecord& cr,const DtExtent& e) const;

   // reduce the grid object to two DtTriangleIndirects if the height and surface
   // are uniform across the grid.Otherwise, return the grid unaltered.
   virtual DtGdbNode* reduce(int& numReductions);

   // expand the input extent to include all of the terrain
   // represented by the grid.
   virtual  void expandExtent(DtExtent& extent) const;

   // determines the intersection of chord with the terrain
   // section represented by the grid.
   virtual  bool intersect(const DtChord& chord, 
                           DtPoint& intersectionPoint, 
                           double& intersectionTime) const;

   // Computes the intersection of the terrain section represented by the grid
   // and a chord. In addition to the intersection point and a parametric
   // value, optionally computes and returns surface description for the
   // intersecting surface, and normal. Identifies the lowest level
   // intersecting polygon.  This function will only replace the contents of
   // the intersection record if it finds an intersection with a smaller
   // intersectionTime value.
   virtual  bool intersect(const DtChord& chord, 
      DtChordIntersectionRecord& record, DtIntersectRecordType irtFlag) const;

   // Computes the list of all intersections of a chord with terrain section
   // represented by the DtGrid. Adds to a list of DtChordIntersectionRecords
   // sorted by distance along the chord. Returns false if no intersections
   // exist.
   virtual bool allIntersectsAlongChord(const DtChord& chord,
      DtChordIntersectRecordList& intList,
      DtIntersectRecordType irtFlag) const;

   // Computes the intersection of terrain section represented by the terrain
   // section represented by the grid and a bundle of chords. The returned
   // record list is a a DtList of DtChordIntersectionRecords (one for each
   // chord) each of which must be created and deleted by the caller.  The
   // irtFlag value specifies which data should be calculated and returned for
   // each intersection point.  The return value of this function is the
   // number of the chords that had any intersections with the terrain.  This
   // function will only replace the contents of the intersection records if
   // it finds an intersection with a smaller intersectionTime value.
   virtual int intersectBundle(const DtChordBundle& chordBundle,
      DtList& recordList, DtIntersectRecordType irtFlag) const;

   // Computes the list of all intersections of each of a bundle of chords
   // with the grid.  For each chord in the bundle, adds to a matching
   // DtChordIntersectRecordList sorted by distance along the chord.  The
   // caller is responsible for creating and deleting the
   // DtChordIntersectRecordLists in the intListList DtList.  The return value
   // of this function is the number of the chords that had any intersections
   // with the terrain.  Note that passing an irtFlag value of IRT_NO_DATA
   // will probably never return more than one intersection per chord.
   virtual int allIntersectsAlongChordBundle(const DtChordBundle& chordBundle,
      DtList& intListList, DtIntersectRecordType irtFlag) const;

   // returns the vertices of a grid triangle in vertices v0, v1,
   // and v2, given its enumeration. The vertices are in counter-
   // clockwise order.
   virtual bool getTriangleVertices(int polyNum, 
                                    DtPoint& v0,
                                    DtPoint& v1,
                                    DtPoint& v2,
                                    DtSurface& triSurface) const;

   // returns true if all of the posts have the same elevation
   // and soiltype is uniform.The uniform height is returned in h,
   // and a poinetr to the uniform surface is returned in s.
   virtual bool isUniformHeightAndSurface(DtSurfaceID& surfID, 
                                          double& h) const;

   // returns true if all of the posts have the same
   // soiltype.  The ID of the uniform surface is returned in surfID.
   virtual bool isUniformSurface(DtSurfaceID& surfID) const;

   // given polyNum, construct and return the triangle indexed by
   // polynum.
//   virtual  bool reconstructPoly(int polynum, DtPolygonImmediate& poly) const;

   // prints the contents of the object
   virtual void dump(int indentLevel) const;

   virtual int sizeInBytes() const;

protected:

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

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

   // initialization
   virtual void init();

   // given an extent, compute the smallest subgrid that overlaps
   // the extent in x and y dimensions.
   virtual void computeOverlappingSubGrid(const DtExtent& chordExtent,
                      int&  minPostNum, int& maxPostNum) const;

   // given a chord and a post number, return the segment of the chord 
   // that overlaps the post.
   virtual void getChordSegment(const DtChord& chord, int postNum, 
                   DtChord& chordSegment) const;

   // given a point in 3-space, determine if the point lies
   // directly above(below) the square area associated with
   // a post.
   virtual bool pointProjectsOntoPost(const DtPoint& p,
                                      int PostNum) const;

   // determines if chord intersects a grid triangle; returns intersection
   // point and parametric value, if intersection exists.
   virtual bool intersects(const DtChord& chord, 
                           int polyNum,
                           DtPoint& intersectionPoint, 
                           double& intersectionTime) const;

   // determines if chord intersects a grid triangle; returns intersection
   // record, if intersection exists.
   virtual bool intersects(const DtChord& chord, 
                           int polyNum,
                           DtChordIntersectionRecord& record,
                           DtIntersectRecordType irtFlag = DtGdbNode::IRT_ALL_DATA_TERRAIN) const;


protected:

   // Terrain database which holds pointers to the vertex and surface managers
   // as well as the memory manager.
   DtTerrainDatabase* myTerrainDb;

   DtGridPostList*   myGridPostList;
   int               myNumWide;
   int               myNumHigh;
   int               myStartingGridpostIndex;

   DtExtent          myExtent;
   DtVertex          myBottomLeftVertex;
   DtVertex          myTopRightVertex;
};


// returns the type of gdb node
inline DtGdbNode::DtGdbNodeType DtGrid::type() const
{
   return DtGdbNode::GRID;
}

// returns the number of posts in the grid
inline int DtGrid::numberOfPosts(void) const
{
   return (myNumWide * myNumHigh);
}

// return the bottom left vertex of grid
inline const DtVertex& DtGrid::bottomLeftVertex() const
{
   return myBottomLeftVertex;
}

// return the top right vertex of grid
inline const DtVertex& DtGrid::topRightVertex() const
{
   return(myTopRightVertex);
}

//returns the width of the grid measured in number of posts.
inline int DtGrid::width() const
{
   return myNumWide;
}

//returns the height of the grid measured in number of posts.
inline int DtGrid::height() const
{
   return myNumHigh;
}

// returns the starting post index of the grid with reference to its
// grid post list.
inline int DtGrid::startingGridPostIndex() const
{
   return myStartingGridpostIndex;
}

//returns pointer to gridpost list associated with the grid.
inline DtGridPostList* DtGrid::gridPostList() const
{
   return myGridPostList;
}

// returns the extent of the grid
inline const DtExtent& DtGrid::extent() const
{  
   return myExtent;     
}

#endif