baseCoordinateSystem.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 1999 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/
/******************************************************************************
** $RCSfile: baseCoord.h,v $ $Revision: 1.18 $ $State: Exp $
******************************************************************************/
#ifndef baseCoordinateSystem_H_
#define baseCoordinateSystem_H_

#include "gdb/gdbDefines.h"
#include "gdb/gdbNode.h"
#include "geometry/homogeneousTransformMatrix.h"

//forward declarations
class DtTerrainDatabase;
class DtExtent;
class DtChord;
class DtChordBundle;
class DtChordIntersectionRecord;
class DtChordIntersectRecordList;
class DtAllTypesPolygon;

//
// Coordinate system.
//
class DT_DLL_gdb DtBaseCoordinateSystem: public DtGdbNode
{
  public:

   DtBaseCoordinateSystem();

   virtual ~DtBaseCoordinateSystem();

private:
   // Copy constructor and Assignment operator not implemented
   DtBaseCoordinateSystem(const DtBaseCoordinateSystem& original);
   DtBaseCoordinateSystem& operator=(const DtBaseCoordinateSystem& original);

public:

   virtual DtGdbNode* child();
   virtual const DtGdbNode* child() const;
   virtual void setChild(DtGdbNode* node);

   virtual const DtHomogeneousTransformMatrix& fromChildXformForPoints() const;
   virtual void setFromChildXformForPoints(DtHomogeneousTransformMatrix& matrix);

   virtual const DtHomogeneousTransformMatrix& toChildXformForPoints() const;
   virtual void setToChildXformForPoints(DtHomogeneousTransformMatrix& matrix);

   virtual void   dump(int indentLevel) 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;
   
   // 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 DtBaseCoordinateSystem node by reducing its child node.
   virtual DtGdbNode* reduce(int& numReductions);

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

   virtual void expandExtent(DtExtent& extent) const;

   // Forces the child to recalculate its extent
   virtual void recomputeExtent();

   // Computes the intersection of the terrain section below the coordinate
   // system node 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 the terrain section below the coordinate
   // system node 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 the terrain
   // section below the coordinate system node object.  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 the terrain
   // section below the coordinate system node 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 below the coordinate system node object.  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;

   void      initOtherMatricesFromMyToChildXformForPoints(void);
   void      initOtherMatricesFromMyFromChildXformForPoints(void);

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

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

   // Applies the input matrix to itself and its children as appropriate.
   //
   // Concatenates member homogeneous transform with specified transform 
   // matrix to create a transformation from child coords all
   // the way to world coords.
   // Returns false if the transform failed for any reason.
   // (after using, in parent node, should replace coordinate system 
   // node with its child node.)
   // Note:  If the transform matrix is non-identity, will change the
   // flag to true if it is already not.
   virtual bool applyTransform(const DtHomogeneousTransformMatrix& matrix,
                                bool createNewVertices);

   virtual int sizeInBytes() const;

protected:


   // Copy a given polygon to my Coordinate system
   virtual DtAllTypesPolygon* copyPolygonToMyCs(
      const DtAllTypesPolygon& orig) const;

   // Translate a given intersection record to my Coordinate system
   virtual void chordIntersectionRecordChildsCsToMyCs(
      const DtChordIntersectionRecord& recordInChildsCs,
      DtChordIntersectionRecord& recordInMyCs,
      DtIntersectRecordType irtFlag) const;

   // Translate a given list of intersection records to my Coordinate system.
   // This modifies the records in its first argument!
   virtual void chordIntersectRecordListChildsCsToMyCs(
      DtChordIntersectRecordList& intListInChildsCs,
      DtIntersectRecordType irtFlag) const;
    
    DtGdbNode* myChild;

    DtHomogeneousTransformMatrix      myToChildXformForPoints;
    DtHomogeneousTransformMatrix      myFromChildXformForPoints;
};

inline DtGdbNode* DtBaseCoordinateSystem::child()
{
   return myChild;
}
inline const DtGdbNode* DtBaseCoordinateSystem::child() const 
{
   return myChild;
}

inline void DtBaseCoordinateSystem::setChild(DtGdbNode* node)
{
  myChild = node;
}

inline const DtHomogeneousTransformMatrix& DtBaseCoordinateSystem::fromChildXformForPoints() const
{
   return myFromChildXformForPoints; 
}

inline void DtBaseCoordinateSystem::setFromChildXformForPoints(
   DtHomogeneousTransformMatrix& matrix)
{
   myFromChildXformForPoints = matrix;
}

inline const DtHomogeneousTransformMatrix& DtBaseCoordinateSystem::toChildXformForPoints() const
{
   return myToChildXformForPoints; 
}

inline void DtBaseCoordinateSystem::setToChildXformForPoints(
   DtHomogeneousTransformMatrix& matrix)
{
   myToChildXformForPoints = matrix;
}

/****************************************************************
 * Dynamic coordinate system.
 ****************************************************************/

class DtDynamicCoordinateSystem: public DtBaseCoordinateSystem
{
  public:

    DtDynamicCoordinateSystem();

    void         dump(int indentLevel) const;
    DtGdbNodeType      type(void) const;
};


/****************************************************************
 * Static coordinate system.
 ****************************************************************/


class DtStaticCoordinateSystem: public DtBaseCoordinateSystem
{
  public:

    DtStaticCoordinateSystem();

    void         dump(int indentLevel) const;
    DtGdbNodeType      type(void) const;
};

#endif