NAME

SYNOPSIS

class VTK_EXPORT vtkPolygon : public vtkCell

vtkPolygon() {};
vtkPolygon(const vtkPolygon& p);
static vtkPolygon *New() {return new vtkPolygon;};
const char *GetClassName() {return "vtkPolygon";};
vtkCell *MakeObject() {return new vtkPolygon(*this);};
int GetCellType() {return VTK_POLYGON;};
int GetCellDimension() {return 2;};
int GetNumberOfEdges() {return this->GetNumberOfPoints();};
int GetNumberOfFaces() {return 0;};
vtkCell *GetEdge(int edgeId);
vtkCell *GetFace(int) {return 0;};
int CellBoundary(int subId, float pcoords[3], vtkIdList& pts);
void Contour(float value, vtkFloatScalars *cellScalars,
vtkPointLocator *locator,vtkCellArray *verts,
vtkCellArray *lines, vtkCellArray *polys,
vtkPointData *inPd, vtkPointData *outPd);
void Clip(float value, vtkFloatScalars *cellScalars,
vtkPointLocator *locator, vtkCellArray *tris,
vtkPointData *inPd, vtkPointData *outPd, int insideOut);
int EvaluatePosition(float x[3], float closestPoint[3],
int& subId, float pcoords[3],
float& dist2, float *weights);
void EvaluateLocation(int& subId, float pcoords[3], float x[3],
float *weights);
int IntersectWithLine(float p1[3], float p2[3], float tol, float& t,
float x[3], float pcoords[3], int& subId);
int Triangulate(int index, vtkIdList &ptIds, vtkFloatPoints &pts);
void Derivatives(int subId, float pcoords[3], float *values,
int dim, float *derivs);
static void ComputeNormal(vtkPoints *p, int numPts, int *pts, float n[3]);
static void ComputeNormal(vtkFloatPoints *p, float n[3]);
static void ComputeNormal(int numPts, float *pts, float n[3]);
void ComputeWeights(float x[3], float *weights);
int ParameterizePolygon(float p0[3], float p10[3], float &l10,
float p20[3], float &l20, float n[3]);
static int PointInPolygon(float x[3], int numPts, float *pts, float bounds[6],
float n[3]);
int Triangulate(vtkIdList &outTris);
int FastTriangulate(int numVerts, int *verts, vtkIdList& Tris);
int SlowTriangulate(int numVerts, int *verts, float planeNormal[3],
vtkIdList& Tris);
int CanSplitLoop(int fedges[2], int numVerts, int *verts, int& n1, int *l1,
int& n2, int *l2, float& ar);
void SplitLoop (int fedges[2], int numVerts, int *verts, int& n1, int *l1,
int& n2, int* l2);
static int IntersectPolygonWithPolygon(int npts, float *pts, float bounds[6],
int npts2, float *pts2,
float bounds2[3], float tol,
float x[3]);

DESCRIPTION

SUMMARY

vtkPolygon(const vtkPolygon& p)
Deep copy of cell.

void ComputeNormal(vtkPoints *p, int numPts, int *pts, float *n)
Compute the polygon normal from a points list, and a list of point ids that index into the points list. This version will handle non-convex polygons.

void ComputeNormal(vtkFloatPoints *p, float *n)
Compute the polygon normal from a list of floating points. This version will handle non-convex polygons.

void ComputeNormal (int numPts, float *pts, float n[3]) Compute the polygon normal from an array of points. This version assumes that the polygon is convex, and looks for the first valid normal.

int ParameterizePolygon(float *p0, float *p10, float& l10, float *p20,float &l20, float *n)
Create a local s-t coordinate system for a polygon. The point p0 is the origin of the local system, p10 is saxis vector, and p20 is the t-axis vector. (These are expressed in the modelling coordinate system and are vectors of dimension [3].) The values l20 and l20 are the lengths of the vectors p10 and p20, and n is the polygon normal.

int PointInPolygon (float x[3], int numPts, float *pts, float bounds[6], float *n) Determine whether point is inside polygon. Function uses ray-casting to determine if point is inside polygon. Works for arbitrary polygon shape (e.g., nonconvex). Returns 0 if point is not in polygon; 1 if it is. Can also return -1 to indicate degenerate polygon.

int Triangulate(vtkIdList &outTris)
Triangulate polygon. Tries to use the fast triangulation technique first, and if that doesn't work, uses more complex routine that is guaranteed to work.

int FastTriangulate (int numVerts, int *verts, vtkIdList& Tris)
A fast triangulation method. Uses recursive divide and conquer based on plane splitting to reduce loop into triangles. The cell (e.g., triangle) is presumed properly initialized (i.e., Points and PointIds).

int CanSplitLoop (int fedges[2], int numVerts, int *verts, int& n1, int *l1, int& n2, int *l2, float& ar)
Determine whether the loop can be split / build loops

void SplitLoop (int fedges[2], int numVerts, int *verts, int& n1, int *l1, int& n2, int* l2)
Creates two loops from splitting plane provided

int SlowTriangulate (int numVerts, int *verts,

float

planeNormal[3], vtkIdList& Tris) Polygon triangulation that will always work - although may be slow. Uses explicit analysis technique to split triangles into loops, which are recursively split until only triangles remain. Very similar to the FastTriangulate method, except that extra edge intersection and containment tests are used to insure a valid splitting edge.

int IntersectPolygonWithPolygon(int npts, float *pts,float bounds[6],
int npts2, float *pts2,
float
bounds2[6], float tol2,
float x[3])
Method intersects two polygons. You must supply the number of points and point coordinates (npts, *pts) and the bounding box (bounds) of the two polygons. Also supply a tolerance squared for controlling error. The method returns 1 if there is an intersection, and 0 if not. A single point of intersection x[3] is also returned if there is an intersection.

Table of Contents

• NAME
• SYNOPSIS
• DESCRIPTION
• SUMMARY