Polygon2d (Artisynth API documentation)

java.lang.Object
- maspack.geometry.Polygon2d

All Implemented Interfaces:

java.lang.Iterable<Vertex2d>, HasRenderProps, IsRenderable, IsSelectable, Renderable

Direct Known Subclasses:

ConvexPolygon2d
```
public class Polygon2d
extends java.lang.Object
implements Renderable, java.lang.Iterable<Vertex2d>
```

Field Summary
- Fields inherited from interface maspack.render.IsRenderable
  TRANSPARENT, TWO_DIMENSIONAL

Constructor Summary

Constructors
Constructor and Description
`Polygon2d()`
`Polygon2d(java.util.Collection<? extends Point2d> pnts)`
`Polygon2d(java.util.Collection<? extends Point3d> pnts, RigidTransform3d TPW)`
`Polygon2d(double[] coords)`
`Polygon2d(Point2d[] pnts)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Vertex2d`	`addVertex(double x, double y)`
`void`	`appendVertex(Vertex2d vtx)`
`void`	`clear()`
`double`	`computeArea()`
`double`	`computeAreaIntegrals(Vector2d moa1, Vector3d moa2)` Computes the area integrals of this polygon.
`double`	`computeLength()`
`RenderProps`	`createRenderProps()` Factory method to create render properties appropriate to this object.
`boolean`	`epsilonEquals(Polygon2d poly, double eps)` Returns true if this polygon is equal to another polygon within a prescribed tolerance eps.
`boolean`	`equals(Polygon2d poly)` Returns true if this polygon is equal to another polygon.
`void`	`getBounds(Point2d minValues, Point2d maxValues)`
`void`	`getCentroid(Point2d pnt)`
`Vertex2d`	`getFirstVertex()`
`Vertex2d`	`getLastVertex()`
`double`	`getMaxCoordinate()`
`Point2d[]`	`getPoints()`
`int`	`getRenderHints()` Returns a bit code giving rendering hints about this renderable.
`RenderProps`	`getRenderProps()` Returns the render properities for this object.
`void`	`getSelection(java.util.LinkedList<java.lang.Object> list, int qid)` Append to `list` the component (or components) associated with the `qid`-th selection query issued by this component's render method.
`java.util.ListIterator`	`getVertices()`
`Point2d`	`intersectRay(Point2d p, Vector2d u)` Intersects this polygon with a ray defined by p + s u, using O(n) search of all edges.
`void`	`inverseTransform(AffineTransform2dBase X)` Applies an inverse affine transformation to the vertices of this polygon.
`boolean`	`isConsistent()`
`boolean`	`isConvex()` Returns `true` if this 2d polygon is convex.
`boolean`	`isConvex(double angTol)` Returns `true` if this 2d polygon is convex, within a presribed angular tolerance.
`boolean`	`isEmpty()`
`boolean`	`isSelectable()` Returns true if this object is in fact selectable.
`java.util.Iterator<Vertex2d>`	`iterator()`
`Vertex2d`	`nearestEdge(Point2d nearPnt, Point2d pnt)` Finds a nearest edge of this polygon to a given point, using a simple O(n) search of all edges.
`int`	`numSelectionQueriesNeeded()` If this selectable manages its own selection (by issuing selection queries within its `render` method), then this method should return the maximum number of selection queries that will be required.
`int`	`numVertices()`
`void`	`prependVertex(Vertex2d vtx)`
`void`	`prerender(RenderList list)` Called prior to rendering to allow this object to update the internal state required for rendering (such as by caching rendering coordinates).
`void`	`render(Renderer renderer, int flags)` Render this object using the functionality of the supplied `Renderer`.
`void`	`render(Renderer renderer, RenderProps props, int flags)`
`void`	`scan(ReaderTokenizer rtok)`
`void`	`set(java.util.Collection<? extends Point2d> pnts)`
`void`	`set(java.util.Collection<? extends Point3d> pnts, RigidTransform3d TPW)`
`void`	`set(double[] coords, int numVertices)`
`void`	`set(Point2d[] pnts, int numVertices)`
`void`	`set(Polygon2d poly)`
`void`	`setRenderProps(RenderProps props)` Assigns a new set of render properties to this object.
`void`	`shiftFirstVertex()`
`void`	`shiftVertices(int n)`
`ConvexPolygon2d`	`simpleConvexHull()` Computes the convex hull of this Polygon2d, under the assumption that it describes a simple polygon.
`static ConvexPolygon2d`	`simpleConvexHull(java.util.Collection<Point2d> pnts)` Computes the convex hull of a list of points, under the assumption that they describe a simple polygon.
`java.lang.String`	`toString()`
`java.lang.String`	`toString(NumberFormat fmt)`
`java.lang.String`	`toString(java.lang.String fmtStr)`
`void`	`transform(AffineTransform2dBase X)` Applies a affine transformation to the vertices of this polygon.
`void`	`updateBounds(Point2d minValues, Point2d maxValues)`
`void`	`updateBounds(Vector3d pmin, Vector3d pmax)` Update the minimum and maximum points for this object.

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Constructor Detail
  - Polygon2d
```
public Polygon2d()
```
  - Polygon2d
```
public Polygon2d(double[] coords)
```
  - Polygon2d
```
public Polygon2d(Point2d[] pnts)
```
  - Polygon2d
```
public Polygon2d(java.util.Collection<? extends Point2d> pnts)
```
  - Polygon2d
```
public Polygon2d(java.util.Collection<? extends Point3d> pnts,
                 RigidTransform3d TPW)
```
- Method Detail
  - getVertices
```
public java.util.ListIterator getVertices()
```
  - iterator
```
public java.util.Iterator<Vertex2d> iterator()
```
    Specified by:
    
    iterator in interface java.lang.Iterable<Vertex2d>
  - getPoints
```
public Point2d[] getPoints()
```
  - nearestEdge
```
public Vertex2d nearestEdge(Point2d nearPnt,
                            Point2d pnt)
```
    Finds a nearest edge of this polygon to a given point, using a simple O(n) search of all edges. The edge is represented by its starting vertex. Note that the nearest edge is generally unique only if the polygon is convex and pnt is outside it.
    
    Parameters:
    
    nearPnt - if non-null, returns the point nearest to pnt
    
    pnt - point for which the nearest distance is sought
  - intersectRay
```
public Point2d intersectRay(Point2d p,
                            Vector2d u)
```
    Intersects this polygon with a ray defined by p + s u, using O(n) search of all edges. If there is more than one intersection, the nearest to p is returned.
    
    Parameters:
    
    p - starting point of the ray
    
    u - direction of the ray
    
    Returns:
    
    intersection point, or null if none
  - numVertices
```
public int numVertices()
```
  - getMaxCoordinate
```
public double getMaxCoordinate()
```
  - getBounds
```
public void getBounds(Point2d minValues,
                      Point2d maxValues)
```
  - updateBounds
```
public void updateBounds(Point2d minValues,
                         Point2d maxValues)
```
  - addVertex
```
public Vertex2d addVertex(double x,
                          double y)
```
  - appendVertex
```
public void appendVertex(Vertex2d vtx)
```
  - prependVertex
```
public void prependVertex(Vertex2d vtx)
```
  - isEmpty
```
public boolean isEmpty()
```
  - getLastVertex
```
public Vertex2d getLastVertex()
```
  - getFirstVertex
```
public Vertex2d getFirstVertex()
```
  - clear
```
public void clear()
```
  - shiftFirstVertex
```
public void shiftFirstVertex()
```
  - getCentroid
```
public void getCentroid(Point2d pnt)
```
  - computeLength
```
public double computeLength()
```
  - computeArea
```
public double computeArea()
```
  - computeAreaIntegrals
```
public double computeAreaIntegrals(Vector2d moa1,
                                   Vector3d moa2)
```
    Computes the area integrals of this polygon. The code is based on the surface integral approach used in "Fast and Accurate Computation of Polyhedral Mass Properties," Brian Mirtich, journal of graphics tools, volume 1, number 2, 1996. For polygons, the computations are simpler and can be done by traversing the polygonal boundary.
    The polygon can be ordered either clockwise or counter-clockwise.
    
    Parameters:
    
    moa1 - if non-null, returns the first moment of area
    
    moa2 - if non-null, returns the second moment of area (in x and y), and the product of area (in z)l
    
    Returns:
    
    area of the polygon
  - set
```
public void set(Polygon2d poly)
```
  - set
```
public void set(double[] coords,
                int numVertices)
```
  - set
```
public void set(Point2d[] pnts,
                int numVertices)
```
  - set
```
public void set(java.util.Collection<? extends Point2d> pnts)
```
  - set
```
public void set(java.util.Collection<? extends Point3d> pnts,
                RigidTransform3d TPW)
```
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - toString
```
public java.lang.String toString(java.lang.String fmtStr)
```
  - toString
```
public java.lang.String toString(NumberFormat fmt)
```
  - scan
```
public void scan(ReaderTokenizer rtok)
          throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - epsilonEquals
```
public boolean epsilonEquals(Polygon2d poly,
                             double eps)
```
    Returns true if this polygon is equal to another polygon within a prescribed tolerance eps. The two polyons are considered to be equal if their vertex lists are equal (within the specified tolerance) except for possibly being shifted with respect to each other.
    
    Parameters:
    
    poly - polygon to be compared with
    
    eps - tolerance value
    
    Returns:
    
    true if the polygons are equal
    
    See Also:
    
    epsilonEquals(maspack.geometry.Polygon2d, double)
  - equals
```
public boolean equals(Polygon2d poly)
```
    Returns true if this polygon is equal to another polygon. The two polyons are considered to be equal if their vertex lists are equal except for possibly being shifted with respect to each other.
    
    Parameters:
    
    poly - polygon to be compared with
    
    Returns:
    
    true if the polygons are equal
    
    See Also:
    
    epsilonEquals(maspack.geometry.Polygon2d, double)
  - shiftVertices
```
public void shiftVertices(int n)
```
  - isConsistent
```
public boolean isConsistent()
```
  - transform
```
public void transform(AffineTransform2dBase X)
```
    Applies a affine transformation to the vertices of this polygon.
    
    Parameters:
    
    X - affine transformation
  - inverseTransform
```
public void inverseTransform(AffineTransform2dBase X)
```
    Applies an inverse affine transformation to the vertices of this polygon.
    
    Parameters:
    
    X - affine transformation
  - prerender
```
public void prerender(RenderList list)
```
    Description copied from interface: IsRenderable
    
    Called prior to rendering to allow this object to update the internal state required for rendering (such as by caching rendering coordinates). The object may add internal objects to the list of objects being rendered, by calling
    list.addIfVisible (obj);
    for each of the objects in question.
    
    Specified by:
    
    prerender in interface IsRenderable
    
    Parameters:
    
    list - list of objects to be rendered
  - updateBounds
```
public void updateBounds(Vector3d pmin,
                         Vector3d pmax)
```
    Description copied from interface: IsRenderable
    
    Update the minimum and maximum points for this object. In an x-y-z coordinate system with x directed to the right and y directed upwards, the minimum and maximum points can be thought of as defining the left-lower-far and right-upper-near corners of a bounding cube. This method should only reduce the elements of the minimum point and increase the elements of the maximum point, since it may be used as part of an iteration to determine the bounding cube for several different objects.
    
    Specified by:
    
    updateBounds in interface IsRenderable
    
    Parameters:
    
    pmin - minimum point
    
    pmax - maximum point
  - render
```
public void render(Renderer renderer,
                   int flags)
```
    Description copied from interface: IsRenderable
    
    Render this object using the functionality of the supplied Renderer.
    
    Specified by:
    
    render in interface IsRenderable
    
    Parameters:
    
    renderer - provides the functionality used to perform the rendering.
    
    flags - flags that may be used to control different aspects of the rendering. Flags are defined in Renderer and currently include Renderer.HIGHLIGHT and Renderer.SORT_FACES.
  - render
```
public void render(Renderer renderer,
                   RenderProps props,
                   int flags)
```
  - getRenderHints
```
public int getRenderHints()
```
    Description copied from interface: IsRenderable
    
    Returns a bit code giving rendering hints about this renderable. Current bit codes include TRANSPARENT and TWO_DIMENSIONAL.
    
    Specified by:
    
    getRenderHints in interface IsRenderable
    
    Returns:
    
    bit code of rendering hints.
  - createRenderProps
```
public RenderProps createRenderProps()
```
    Description copied from interface: HasRenderProps
    
    Factory method to create render properties appropriate to this object.
    
    Specified by:
    
    createRenderProps in interface HasRenderProps
    
    Returns:
    
    new render properties for this object
  - setRenderProps
```
public void setRenderProps(RenderProps props)
```
    Description copied from interface: HasRenderProps
    
    Assigns a new set of render properties to this object. An argument of null will remove render properties from this object.
    
    Specified by:
    
    setRenderProps in interface HasRenderProps
    
    Parameters:
    
    props - new render properties for this object
  - getRenderProps
```
public RenderProps getRenderProps()
```
    Description copied from interface: HasRenderProps
    
    Returns the render properities for this object. If no render properties are assigned, this routines returns null.
    
    Specified by:
    
    getRenderProps in interface HasRenderProps
    
    Returns:
    
    current render properties for this object
  - isSelectable
```
public boolean isSelectable()
```
    Description copied from interface: IsSelectable
    
    Returns true if this object is in fact selectable.
    
    Specified by:
    
    isSelectable in interface IsSelectable
    
    Returns:
    
    true if this object is selectable
  - numSelectionQueriesNeeded
```
public int numSelectionQueriesNeeded()
```
    Description copied from interface: IsSelectable
    
    If this selectable manages its own selection (by issuing selection queries within its render method), then this method should return the maximum number of selection queries that will be required. Otherwise, this method should return -1.
    
    Specified by:
    
    numSelectionQueriesNeeded in interface IsSelectable
    
    Returns:
    
    maximum number of selection queries needed by this component, or -1 if this component does not manage its own selection.
  - getSelection
```
public void getSelection(java.util.LinkedList<java.lang.Object> list,
                         int qid)
```
    Description copied from interface: IsSelectable
    
    Append to list the component (or components) associated with the qid-th selection query issued by this component's render method. This will only be called if this component manages its own selection (i.e., the number nums returned by IsSelectable.numSelectionQueriesNeeded() is positive), and qid will in turn be a number between 0 and nums-1.
    
    Specified by:
    
    getSelection in interface IsSelectable
    
    Parameters:
    
    list - selected objects are appended to the end of this list
    
    qid - index of the selection query
  - simpleConvexHull
```
public ConvexPolygon2d simpleConvexHull()
```
    Computes the convex hull of this Polygon2d, under the assumption that it describes a simple polygon. The result is returned as a ConvexPolygon2d, with vertices arranged counter-clockwise.
    The method uses the O(n) time algorithm described by A Melkman, "On-Li Construction of the Convex Hull of a Simple Polyline", Information Processing Letters (1987). The implementation does not use robust predicates and so may produce results that are inaccurate at a machine-precision level.
  - simpleConvexHull
```
public static ConvexPolygon2d simpleConvexHull(java.util.Collection<Point2d> pnts)
```
    Computes the convex hull of a list of points, under the assumption that they describe a simple polygon. The result is returned as a ConvexPolygon2d, with vertices arranged counter-clockwise.
    The method is the same as that used by simpleConvexHull().
  - isConvex
```
public boolean isConvex()
```
    Returns true if this 2d polygon is convex.
  - isConvex
```
public boolean isConvex(double angTol)
```
    Returns true if this 2d polygon is convex, within a presribed angular tolerance.

Class Polygon2d

Field Summary

Fields inherited from interface maspack.render.IsRenderable

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Constructor Detail

Polygon2d

Polygon2d

Polygon2d

Polygon2d

Polygon2d

Method Detail

getVertices

iterator

getPoints

nearestEdge

intersectRay

numVertices

getMaxCoordinate

getBounds

updateBounds

addVertex

appendVertex

prependVertex

isEmpty

getLastVertex

getFirstVertex

clear

shiftFirstVertex

getCentroid

computeLength

computeArea

computeAreaIntegrals

set

set

set

set

set

toString

toString

toString

scan

epsilonEquals

equals

shiftVertices

isConsistent

transform

inverseTransform

prerender

updateBounds

render

render

getRenderHints

createRenderProps

setRenderProps

getRenderProps

isSelectable

numSelectionQueriesNeeded

getSelection

simpleConvexHull

simpleConvexHull

isConvex

isConvex