baseTriangle.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 2000 MAK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: baseTri.h,v $ $Revision: 1.21 $ $State: Exp $
*********************************************************************/

#ifndef baseTriangle_H_
#define baseTriangle_H_

#include "gdb/gdbDefines.h"
#include "gdb/allTypesPolygon.h"
#include "geometry/extent.h"
#include "geometry/plane.h"
#include "geometry/surface.h"

#include <matrix/vlVector.h>

// forward declarations
class DtChordBundle;
class DtSurface;
class DtTerrainDatabase;

// class DtBaseTriangle:
//
// DtBaseTriangle is an base class for triangles
class DT_DLL_gdb DtBaseTriangle : public DtAllTypesPolygon
{
protected:
   //constructor is protected as this is an abstract
   //base class. 
   DtBaseTriangle();

   // destructor
   virtual ~DtBaseTriangle();

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

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

public:

   // number of vertices 
   virtual unsigned int numberOfVertices() const;

   // returns plane through the triangle
   virtual DtPlane plane() const;

   // returns extent of the triangle
   virtual DtExtent extent() const = 0;

   // returns normal to the triangle
   virtual DtVector normal() const;
   
   // for edge, plane, and normal.
   virtual bool getEdge(DtChord& edge, int edgeNumber) const;
   virtual void getPlane(DtPlane& plane) const;
   virtual void getNormal(DtVector& normal) const;

   //geometric functions
   //redefine other extent to include all the vertices of the
   //polygon.
   virtual void expandExtent(DtExtent& otherExtent) const;

   // Computes the intersection of the specified chord with the triangle.
   //
   // \param chordToTest The chord to test for intersection.
   // \param intersectionPoint The intersection point, if one occurred.
   // \param intersectionTime The time along the chord of the intersection. Only set if an intersection occured.
   // \return A boolean indicating whether or not an intersection occurred.
   virtual bool intersect(const DtChord& chordToTest, DtPoint& intersectionPoint, 
      double& intersectionTime) const;

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

   // \copydoc DtGdbNode::intersect(const DtSphere& sphere, 
   // DtSphereIntersectionRecord& record, DtIntersectRecordType irtFlag)
   virtual bool intersect(const DtSphere& sphere, DtSphereIntersectionRecord& record,
      DtIntersectRecordType irtFlag) const;

   

   // if the polygon  falls within the input
   // extent, update the color count in the colorCountRecord which is
   // an in-out parameter.
   virtual void countPolyColors(DtColorCountRecord& cr,const DtExtent& e) const;

   //accessor functions
   virtual bool getVertex(DtPoint& retVal, unsigned int i) const = 0;
   virtual const DtPoint& getVertex(unsigned int i) const = 0;

   // determine if a given point is inside the polygon.
   virtual bool pointInPolygon(const DtPoint& point) const;

   // Finds the point on the specified chord that is closest to this
   // polygon, and returns it in closestPoint.
   // \return Distance squared to the found point.
   // If cutoffDistance is specified (> 0), the first point found within
   // this distance will be returned, even if it is not the closest point.
   // This may cut down significantly on the calculation when the actual
   // closest point is not required.
   virtual double closestPointOnChordToPolygon(const DtChord& chord, 
      DtPoint& closestPoint, double cutoffDistance = 0.) const;

   // determine the minimum and maximum z-values among the
   // vertices in the polygon.
   virtual double minZ() const;
   virtual double maxZ() const;

   // get the surface associated with the polygon
   virtual bool getSurface(DtSurface& surf) const = 0;
   virtual const DtSurface& getSurface() const = 0;
   virtual bool setSurface(const DtSurface& newSurface) = 0;

   virtual int sizeInBytes() const = 0;

protected:
   // compute twice the area of the triangle formed by a, b, c,
   // as the magnitude of the cross product (b-a)X(c-a).
   // Won't be needed later.
   virtual double computeTwiceArea(const DtPoint& a,
      const DtPoint& b, const DtPoint& c) const;
};


inline unsigned int DtBaseTriangle::numberOfVertices() const
{
   return 3;
}

inline double DtBaseTriangle::minZ() const
{
   return extent().minZ();
}

inline double DtBaseTriangle::maxZ() const
{
   return extent().maxZ();
}

inline DtPlane DtBaseTriangle::plane() const
{
   return DtPlane(getVertex(0), getVertex(1), getVertex(2));
}

inline DtVector DtBaseTriangle::normal() const 
{
  return plane().normal();
}



#endif