include/gdb/gdbNode.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1998 MAK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: gdbNode.h,v $ $Revision: 1.27 $ $State: Exp $
*********************************************************************/
#ifndef gdbNode_H_
#define gdbNode_H_

// include files
#include "gdb/gdbDefines.h"
#include "gdb/memManageable.h"
#include "gdb/terrainReader.h"
#include "gdb/gdbNodeEvaluationFunctor.h"
#include <geometry/matrix4x4.h>
#include <vlutil/vlConfig.h>
#include <vlutil/vlList.h>
#include <set>
#include <stdio.h>

// forward declarations
class DtList;
class DtPoint;
class DtChord;
class DtChordBundle;
class DtChordIntersectionRecord;
class DtChordIntersectRecordList;
class DtIntersectionRecord;
class DtExtent;
class DtColorCountRecord;
class DtTerrainDatabase;
class DtMemoryManager;
class DtSimpleList;
class DtSphere;
class DtSphereIntersectionRecord;

//
// DtGdbNode is the basic component  of a GDB terrain 
// database and represents a section of the terrain such as
// a polygon, grid, feature, or a collection of such items. 
// It is an abstract base class. All node types 
// of the GDB are subclassed from this class. 
class DT_DLL_gdb DtGdbNode : public DtMemoryManageable
{
public:

   enum DtGdbNodeType
   {
      NULL_NODE = -1,              
      GRIDPOST_LIST = 0,          // = 0
      VERTEX_LIST,                // = 1
      GROUP,                      // = 2
      POLYGON_IMMEDIATE,          // = 3
      POLYGON_INDIRECT,           // = 4
      LEVEL_OF_DETAIL,            // = 5
      GRID,                       // = 6
      DYNAMIC_COORDINATE_SYSTEM,  // = 7
      STATIC_COORDINATE_SYSTEM,   // = 8
      TERRAIN_FEATURE,            // = 9
      CULTURAL_FEATURE,           // = 10
      BUILDING,                   // = 11
      TREE,                       // = 12
      TRIANGLE_INDIRECT,          // = 13
      FILE_NODE,                  // = 14
      REF_GROUP,                  // = 15
      EXTENT_TRIANGLE_INDIRECT,   // = 16
      LAST_NODE_TYPE
   };
  

   // The Intersect Record Type flag indicates the kind of data requested from
   // a call to one of the intersect functions.  
   enum DtIntersectRecordType
   {
      // NO_DATA returns only a bool indication that an intersection was
      // found.
      IRT_NO_DATA = 0,

      // IPOINT is like IRT_NO_DATA, but also returns the closest intersection
      // point as a DtPoint, the associated "time" value, and the
      // surface type.
      IRT_IPOINT = 0x01,

      // INORMAL is like IRT_NO_DATA, but also returns the normal as a
      // DtWorldCoordVector.
      IRT_INORMAL = 0x02,

      // IPOLYGON is like IRT_NO_DATA, but also returns a copy of the polygon that
      // was hit.
      IRT_IPOLYGON = 0x04,

      // ALL_DATA_TERRAIN requests that all possible data be returned from the terrain node
      IRT_ALL_DATA_TERRAIN = 0x07,

      // VECTOR_DATA is like IRT_NO_DATA, but also returns information about the best
      // intersection in the vector network using only XY coords of the first point the chord
      IRT_VECTOR_DATA_INPOINT = 0x10,

      // VECTOR_DATA is like IRT_NO_DATA, but also returns information about all intersections
      // against the vector network XY coords of the first point the chord
      IRT_VECTOR_DATA_ALONG_CHORD = 0x20,

      // ALL_DATA requests that all possible data be returned from the terrain node and the info 
      // in the point from vector network
      IRT_ALL_DATA_INPOINT = 0x17,

      // ALL_DATA requests that all possible data be returned from the terrain node and from the
      // vector network along the chord.
      IRT_ALL_DATA_ALONG_CHORD = 0x27

   };

   // destructor
   virtual ~DtGdbNode();

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

   // Provides information on the type of the subclassed node.
   virtual DtGdbNodeType type(void) const = 0;

   // Prints out information contained in the node.
   // There is apparently a problem with consistency of argument
   // to this function.
   virtual void dump(int indentLevel) const = 0;

   // Return the minimum terrain file version number that this Node can be
   // saved in.
   virtual DtTerrainFileVersionNumber minSaveVersion() const;

   // Redefines input argument extent such that it encompasses
   // the contents of the DtGdbNode object. Nodes that represent
   // geometric objects should redefine this. By default, it returns
   // the input argument, unchanged.
   virtual void expandExtent(DtExtent& extent) const;

   // Recomputes the extent of node if it has one
   virtual void recomputeExtent();

   // Node applies the transformation matrix to itself and any possible
   // children as appropriate.  The flag specifies whether or not to 
   // create new vertices for the transformed vertices instead of 
   // just modifying existing vertices.
   virtual bool applyTransform(const DtHomogeneousTransfMatrix& matrix,
                               bool createNewVertices);

   // 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 node to a more compact representation.
   virtual DtGdbNode* reduce(int& numReductions);

   // repeatedly invoke the reduce function until no further reduction is
   // possible.
   virtual DtGdbNode* persistentReduce();

   // check the validity of the node
   virtual bool sanityCheck() const;

   // Computes the intersection of terrain section represented by
   // DtGdbNode object and a chord. Returns the intersection point
   // and a parametric value.
   virtual bool intersect(const DtChord& chord, DtPoint& intersectionPoint, 
      double& intersectionTime) const;

   // Computes the intersection of terrain section represented by DtGdbNode
   // object 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;

   // Tests for intersection between the terrain represented by this node
   // and the specified sphere.
   // \return True if an intersection occurs.
   // If irtFlag is IRT_IPOLYGON or higher, a list of all the intersected 
   // polygons is returned inside the record.
   virtual bool intersect(const DtSphere& sphere, DtSphereIntersectionRecord& record,
      DtIntersectRecordType irtFlag) const;

   // Computes the list of all intersections of a chord with terrain section
   // represented by DtGdbNode. Adds to a list of DtChordIntersectionRecords
   // sorted by distance along the chord. Returns false if no intersections
   // exist.  Note that passing an irtFlag value of IRT_NO_DATA will probably
   // never return more than one intersection.
   virtual bool allIntersectsAlongChord(const DtChord& chord,
      DtChordIntersectRecordList& intList, DtIntersectRecordType irtFlag) const;

   // Computes the intersection of terrain section represented by DtGdbNode
   // object 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 terrain section represented by DtGdbNode.  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;

   // The DtFoundInstancesContainer is the container of pointers to DtGdbNode 
   // instances filled in by the allInstancesOf function.  
   typedef std::set<DtGdbNode*> DtFoundInstancesContainer;
   typedef DtFoundInstancesContainer::iterator DtFoundInstancesIter;
   typedef DtFoundInstancesContainer::const_iterator DtFoundInstancesConstIter;

   typedef std::set<const DtGdbNode*> DtFoundInstancesConstContainer;
   typedef DtFoundInstancesConstContainer::iterator DtConstFoundInstancesIter;
   typedef DtFoundInstancesConstContainer::const_iterator DtConstFoundInstancesConstIter;

   // Finds all instances of node type searchType in the tree including and
   // below this node.  This default method only includes the current node,
   // and is overwritten in derived classes as appropriate.
   virtual void allInstancesOf(const DtGdbNodeType searchType, 
      DtFoundInstancesContainer& foundInstances,
      bool recurseIntoCoordSysNodes = false);

   virtual void allInstancesOf(const DtGdbNodeType searchType, 
      DtFoundInstancesConstContainer& foundInstances,
      bool recurseIntoCoordSysNodes = false) const;

   virtual void allInstancesOf(const DtGdbNodeType searchType, 
      DtFoundInstancesContainer& foundInstances,
      bool recurseIntoCoordSysNodes,
      DtGdbNodeEvaluationFunctor& functor);

   virtual void allInstancesOf(const DtGdbNodeType searchType, 
      DtFoundInstancesConstContainer& foundInstances,
      bool recurseIntoCoordSysNodes,
      DtGdbNodeEvaluationFunctor& functor) const;

   
   // Finds and removes all instances of node type searchType in the tree 
   // below this node.
   virtual void purgeAllInstancesOf(const DtGdbNodeType searchType);

   // Finds and removes all instances of every node type in the tree below
   // this node; deletes the nodes if they are not memory managed.  It returns
   // this.
   virtual DtGdbNode* purgeAll();

   // Find the parent (if it exists of child in the tree under the node)
   virtual DtGdbNode* parent(DtGdbNode *child);

   // remove the child (if it is) from this node
   virtual DtGdbNode* removeChild(DtGdbNode *child);

   // Finds and replaces all three-sided polygons with triangles
   // in the tree below this node.  
   virtual void polygonToTriangle(DtMemoryManager* memMgr,
                                  unsigned int& numIndConverted, 
                                  unsigned int& numIndTotal); 

   // Load in all external DtFileNode files.  Returns the number of databases
   // that were just loaded.
   virtual unsigned int loadAllExternalFiles() const;

   // Unload all external DtFileNode files.  Returns the number of databases
   // that were unloaded.
   virtual unsigned int unloadAllExternalFiles() const;

   virtual int sizeInBytes() const = 0;

protected:

   // constructors are protected as this is an 
   // abstract base class.
   DtGdbNode();

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

   DtGdbNode*           myOwner;   // pointer to the node's owner
                                   
};
#endif