include/gdb/basePoly.h

Go to the documentation of this file.

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

#include "gdb/gdbDefines.h"
#include "gdb/allPoly.h"
#include "geometry/plane.h"
#include "geometry/tdbextent.h"
#include <matrix/vlVector.h>

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

// class DtBasePolygon:
//
// DtBasePolygon is an abstract base class for representing
// polygons. A polygon consists of a sequence of vertices in
// counter-clockwise order. It is assumed that all the 
// vertices (if more than 3) are coplanar.
class DT_DLL_gdb DtBasePolygon : public DtAllTypesPolygon
{
public:
   // Destructor
   virtual ~DtBasePolygon();

protected:
   // Constructor is protected as this is an abstract
   // base class. 
   DtBasePolygon();

   // Additional constructor
   DtBasePolygon(unsigned int numVertices);

   // Copy constructor
   DtBasePolygon(const DtBasePolygon& orig);

   // Assignment operator
   DtBasePolygon& operator=(const DtBasePolygon& orig);

public:

   // mutator function
   virtual void setNumberOfVertices(unsigned int n);

   //accessor functions 
   virtual unsigned int numberOfVertices() const;

   // Calls initPlaneAndExtent to force the polygon
   // to recompute the extent.
   virtual void recomputeExtent();

   // initialization function
   virtual void initPlaneAndExtent();

   // @return The plane through the polygon
   virtual DtPlane plane() const;

   // @return The extent of polygon
   // @note Non-virtual to allow inlining.  Very frequently called.
   DtExtent extent() const;

   // returns normal to polygon
   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;

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

   //geometric functions

   //redefine other extent to include all the vertices of the
   //polygon.
   virtual void expandExtent(DtExtent& otherExtent) const;
   
   // computes the intersection of chord with polygon; returns
   // intersection point.
   // \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;

   //accessor functions
   virtual bool getVertex(DtPoint& retVal, unsigned int i) const = 0;
   virtual const DtPoint& getVertex(unsigned int i) const = 0;
   virtual bool getSurface(DtSurface& s) const = 0;
   virtual const DtSurface& getSurface() const = 0;
   virtual bool setSurface(const DtSurface& newSurface) = 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;

   // KLUDGE -- have different max # of verts per type of poly -- JM
   virtual bool isFull() const = 0; 

   virtual int sizeInBytes() const = 0;

protected:
   bool testInvariant() const;

   // compute twice the area of the triangle formed by a, b, c,
   // as the magnitude of the cross product (b-a)X(c-a).
   virtual double computeTwiceArea(
      const DtPoint& a,
      const DtPoint& b,
      const DtPoint& c) const;

protected:

   unsigned int myNumberOfVertices;
   bool         myInitialized;    // used to determine if plane and extent have
                                  // been computed.
   DtPlane      myPlane;
   DtExtent     myExtent;
};

inline double DtBasePolygon::minZ() const
{
   return myExtent.minZ();
}

inline double DtBasePolygon::maxZ() const
{
   return myExtent.maxZ();
}

inline unsigned int DtBasePolygon::numberOfVertices() const
{
   return myNumberOfVertices;
}

inline void DtBasePolygon::setNumberOfVertices(unsigned int n)
{
   myNumberOfVertices = n;
}

inline DtPlane DtBasePolygon::plane() const
{
   return myPlane;
}

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

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

#endif