include/gdb/allPoly.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 2000 MAK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: allPoly.h,v $ $Revision: 1.20 $ $State: Exp $
*********************************************************************/
#ifndef allPoly_H_
#define allPoly_H_

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

// forward declarations
class DtSurface;

// class DtAllTypesPolygon:
//
// DtAllTypesPolygon is an abstract base class for representing
// all types of polygons.  This class contains no new state values.
// A polygon may be a general polygon or a triangle.
class DT_DLL_gdb DtAllTypesPolygon : public DtGdbNode
{
public:
   // destructor
   virtual ~DtAllTypesPolygon();

protected:
   //constructor is protected as this is an abstract
   //base class. 
   DtAllTypesPolygon();

   // copy constructor - unimplemented
   DtAllTypesPolygon(const DtAllTypesPolygon& orig);

   // assignment operator - unimplemented
   DtAllTypesPolygon& operator=(const DtAllTypesPolygon& orig);

public:

   // Accessor functions 

   virtual unsigned int numberOfVertices() const = 0;

   // @return The normal to polygon
   virtual DtVector normal() const = 0;
   
   // @returns True if the specified edge exists, and false if it does not.
   // If the edge exists, it is copied into the specified chord.
   virtual bool getEdge(DtChord& edge, int edgeNumber) const = 0;
   virtual void getNormal(DtVector& normal) const  = 0;

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

   // Geometric functions

   // computes the intersection of chord with polygon; returns
   // intersection point.
   virtual bool intersect(const DtChord& chord, DtPoint& intersectionPoint, double& t) const = 0;

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

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

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

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

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

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

   virtual int sizeInBytes() const = 0;
};

#endif