group.h

Go to the documentation of this file.

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

#ifndef group_H_
#define group_H_

#include "gdb/gdbDefines.h"
#include "gdb/gdbNode.h"
#include "geometry/extent.h"
#include "geometry/homogeneousTransformMatrix.h"
#include <vlutil/vlConfig.h>
#include <list>
#include <vector>
#include <set>

// forward declarations
class DtChordBundle;

// class DtGroup:
//
// DtGroup represents a container of DtGdbNodes.
//
class DT_DLL_gdb DtGroup : public DtGdbNode
{
public:

   typedef std::vector<DtGdbNode*> DtGroupChildren;
   typedef const std::vector<DtGdbNode*> DtConstGroupChildren;
   typedef std::vector<DtGdbNode*>::iterator DtGroupChildrenIter;
   typedef std::vector<DtGdbNode*>::const_iterator DtGroupChildrenConstIter;

   // default constructor
   DtGroup();

   // destructor
   virtual ~DtGroup();

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

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

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

   // Non-virtual to allow inlining.  Very frequently called.
   // Returns the extent of the group
   DtExtent extent() const;

   // returns the group's child nodes.
   virtual DtGroupChildren& children();
   virtual DtConstGroupChildren& children() 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;

   // redefine extent to include all components of the group
   virtual void expandExtent(DtExtent& extent) const;

   // Forces all children to recalculate their extents, and then recomputes
   // the extent for the group using the new extents
   virtual void recomputeExtent();

   // compute the intersection point of chord and the group.
   virtual bool intersect(const DtChord& chord, 
      DtPoint& intersectionPoint, double& t) const;

   // Computes the intersection of the terrain section represented by the
   // group components 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.
   // \note irtFlag is ignored for now.
   virtual bool intersect(const DtSphere& sphere, DtSphereIntersectionRecord& record,
      DtIntersectRecordType irtFlag) const;

   // Computes the list of all intersections of a chord with the terrain
   // section represented by the group components. 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 group 
   // components 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 terrain section represented by the group components.  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;

   // add a node to the group
   // If for some reason, it cannot add the child due to lack of memory, it 
   // throws a std::bad_alloc exception
   // \throws std::bad_alloc
   virtual  void addChild(DtGdbNode* newNode);
   virtual  void addChildIfNonNull(DtGdbNode* newNode);
   virtual  void addChildToStart(DtGdbNode* newNode);

   // collapses any coordinate system nodes below this node
   // matrix is the transform matrix to apply to children of the node
   // - contains transformation necessary to go from child coords all
   // the way back out to world coordinates
   virtual bool applyTransform(const DtHomogeneousTransformMatrix& matrix,
                                bool createNewVertices);

   // Reconstitute the group after each child is reduced, eliminating 
   // child nodes that reduce to null.
   virtual void reduceChildren(int& numReductions);

   // reduce the group object to eliminate redundant nodes.
   virtual DtGdbNode* reduce(int& numReductions);

   // check the object to ensure it is valid.
   virtual bool sanityCheck() const; 

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

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

   // Finds all instances of node type searchType in the tree including and
   // below this node.
   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();

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

   // This method returns a balanced-tree.  branching is the maximum
   // branching factor, and bushiness is the number of leaves in the last
   // group.  This function leaves the old tree intact.
   virtual DtGroup* balanced(unsigned int branching, unsigned int bushiness);

   // This method returns a balanced-tree.  branching is the maximum
   // branching factor, and bushiness is the number of leaves in the last
   // group.  This function purges the groups in the old tree.
   virtual DtGroup* balancedAndPurged(unsigned int branching, unsigned int bushiness); 

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

   virtual void computeExtent();

   virtual int sizeInBytes() const;

protected:

   // Deletes a node iff it is not memory managed.
   virtual void purge(DtGdbNode* node); 

   virtual void dumpComponents(int indentLevel) const;

   virtual void reduceChildrenAux(DtGroupChildren& nodesToBeReduced, 
                                  std::list<DtGdbNode*>& nodesAlreadyReduced, 
                                  int& numReductions);

protected:

   DtExtent myExtent;
   DtGroupChildren myNodes;
};

inline DtGdbNode::DtGdbNodeType DtGroup::type() const
{
   return DtGdbNode::GROUP;
}

inline DtExtent DtGroup::extent() const
{
   return myExtent;
}

inline DtGroup::DtGroupChildren& DtGroup::children()
{
   return myNodes;
}

inline DtGroup::DtConstGroupChildren& DtGroup::children() const
{
   return myNodes;
}

#endif