We distinguish between simple polygons (without holes) and polygons with holes.

Polygons are sequences of points and may or may not contain holes.

Degenerate polygons (polygons with self-intersections or fewer than 3 points) are only possible if you use functions marked as unsafe.

Prism to test if we are a simple polygon

>>> is _SimplePolygon simplePoly
True

Prism to test if we are a Multi polygon

>>> is _MultiPolygon multiPoly
True

Polygon without holes.

Polygon with zero or more holes.

Either a simple or multipolygon

\( O(n) \) Creates a polygon from the given list of vertices.

The points are placed in CCW order if they are not already. Overlapping edges and repeated vertices are allowed.

\( O(n) \) Creates a polygon from the given vector of vertices.

The points are placed in CCW order if they are not already. Overlapping edges and repeated vertices are allowed.

\( O(n \log n) \) Creates a simple polygon from the given list of vertices.

The points are placed in CCW order if they are not already. Overlapping edges and repeated vertices are not allowed and will trigger an exception.

\( O(n \log n) \) Creates a simple polygon from the given vector of vertices.

The points are placed in CCW order if they are not already. Overlapping edges and repeated vertices are not allowed and will trigger an exception.

\( O(n) \) Creates a simple polygon from the given list of vertices.

pre: the input list constains no repeated vertices.

\( O(1) \) Creates a simple polygon from the given vector of vertices.

pre: the input list constains no repeated vertices.

\( O(1) \) Creates a simple polygon from the given vector of vertices.

pre: the input list constains no repeated vertices.

\( O(n) \) Polygon points, from left to right.

\( O(n) \) Polygon points, from left to right.

\( O(n \log n) \) Check if a polygon has any holes, duplicate points, or self-intersections.

\( O(1) \) Vertex count. Includes the vertices of holes.

\( O(n) \) The vertices in the polygon. No guarantees are given on the order in which they appear!

\( O(n) \) Lists all edges. The edges on the outer boundary are given before the ones on the holes. However, no other guarantees are given on the order.

\( O(1) \) Lens access to the outer boundary of a polygon.

Getter access to the outer boundary vector of a polygon.

>>> toList (simpleTriangle ^. outerBoundaryVector)
[Point2 0 0 :+ (),Point2 2 0 :+ (),Point2 1 1 :+ ()]

Unsafe lens access to the outer boundary vector of a polygon.

>>> toList (simpleTriangle ^. unsafeOuterBoundaryVector)
[Point2 0 0 :+ (),Point2 2 0 :+ (),Point2 1 1 :+ ()]

>>> simpleTriangle & unsafeOuterBoundaryVector .~ CV.singleton (Point2 0 0 :+ ())
SimplePolygon [Point2 0 0 :+ ()]

\( O(n) \) The edges along the outer boundary of the polygon. The edges are half open.

O(1) Access the i^th vertex on the outer boundary. Indices are modulo \(n\).

>>> simplePoly ^. outerVertex 0
Point2 0 0 :+ ()

\( O(1) \) Get the n^th edge along the outer boundary of the polygon. The edge is half open.

Lens access for polygon holes.

>>> multiPoly ^. polygonHoles
[SimplePolygon [Point2 0 0 :+ (),Point2 2 0 :+ (),Point2 1 1 :+ ()]]

\( O(1) \). Traversal lens for polygon holes. Does nothing for simple polygons.

Get all holes in a polygon

Compute the area of a polygon

Compute the signed area of a simple polygon. The the vertices are in clockwise order, the signed area will be negative, if the verices are given in counter clockwise order, the area will be positive.

Compute the centroid of a simple polygon.

Check if a point lies inside a polygon, on the boundary, or outside of the polygon. Running time: O(n).

>>> Point2 1 1 `inPolygon` simplePoly
Inside
>>> Point2 0 0 `inPolygon` simplePoly
OnBoundary
>>> Point2 10 0 `inPolygon` simplePoly
OnBoundary
>>> Point2 5 13 `inPolygon` simplePoly
Inside
>>> Point2 5 10 `inPolygon` simplePoly
Inside
>>> Point2 10 5 `inPolygon` simplePoly
OnBoundary
>>> Point2 20 5 `inPolygon` simplePoly
Outside

TODO: Add some testcases with multiPolygons TODO: Add some more onBoundary testcases

Test if a point lies strictly inside the polgyon.

\( O(n) \) Test if q lies on the boundary of the polygon.

>>> Point2 1 1 `onBoundary` simplePoly
False
>>> Point2 0 0 `onBoundary` simplePoly
True
>>> Point2 10 0 `onBoundary` simplePoly
True
>>> Point2 5 13 `onBoundary` simplePoly
False
>>> Point2 5 10 `onBoundary` simplePoly
False
>>> Point2 10 5 `onBoundary` simplePoly
True
>>> Point2 20 5 `onBoundary` simplePoly
False

TODO: testcases multipolygon

\( O(1) \) Test if the polygon is a triangle

Test if a Simple polygon is star-shaped. Returns a point in the kernel (i.e. from which the entire polygon is visible), if it exists.

\(O(n)\) expected time

\( O(n) \) Test if the outer boundary of the polygon is in clockwise or counter clockwise order.

\( O(n) \) Make sure that every edge has the polygon's interior on its left, by orienting the outer boundary into counter-clockwise order, and the inner borders (i.e. any holes, if they exist) into clockwise order.

\( O(n) \) Orient the outer boundary into counter-clockwise order. Leaves any holes as they are.

\( O(n) \) Make sure that every edge has the polygon's interior on its right, by orienting the outer boundary into clockwise order, and the inner borders (i.e. any holes, if they exist) into counter-clockwise order.

\( O(n) \) Orient the outer boundary into clockwise order. Leaves any holes as they are.

Reorient the outer boundary from clockwise order to counter-clockwise order or from counter-clockwise order to clockwise order. Leaves any holes as they are.

\( O(1) \) Rotate the polygon to the left by n number of points.

\( O(1) \) Rotate the polygon to the right by n number of points.

\( O(n) \) Yield the maximum point of a polygon according to the given comparison function.

\( O(n) \) Yield the maximum point of a polygon according to the given comparison function.

\( O(n) \) Pick a point that is inside the polygon.

(note: if the polygon is degenerate; i.e. has <3 vertices, we report a vertex of the polygon instead.)

pre: the polygon is given in CCW order

\( O(n) \) Find a diagonal of the polygon.

pre: the polygon is given in CCW order

Pairs every vertex with its incident edges. The first one is its predecessor edge, the second one its successor edge (in terms of the ordering along the boundary).

>>> mapM_ print . polygonVertices $ withIncidentEdges simplePoly
Point2 0 0 :+ V2 (ClosedLineSegment (Point2 1 11 :+ ()) (Point2 0 0 :+ ())) (ClosedLineSegment (Point2 0 0 :+ ()) (Point2 10 0 :+ ()))
Point2 10 0 :+ V2 (ClosedLineSegment (Point2 0 0 :+ ()) (Point2 10 0 :+ ())) (ClosedLineSegment (Point2 10 0 :+ ()) (Point2 10 10 :+ ()))
Point2 10 10 :+ V2 (ClosedLineSegment (Point2 10 0 :+ ()) (Point2 10 10 :+ ())) (ClosedLineSegment (Point2 10 10 :+ ()) (Point2 5 15 :+ ()))
Point2 5 15 :+ V2 (ClosedLineSegment (Point2 10 10 :+ ()) (Point2 5 15 :+ ())) (ClosedLineSegment (Point2 5 15 :+ ()) (Point2 1 11 :+ ()))
Point2 1 11 :+ V2 (ClosedLineSegment (Point2 5 15 :+ ()) (Point2 1 11 :+ ())) (ClosedLineSegment (Point2 1 11 :+ ()) (Point2 0 0 :+ ()))

assigns unique integer numbers to all vertices. Numbers start from 0, and are increasing along the outer boundary. The vertices of holes will be numbered last, in the same order.

>>> numberVertices simplePoly
SimplePolygon [Point2 0 0 :+ SP 0 (),Point2 10 0 :+ SP 1 (),Point2 10 10 :+ SP 2 (),Point2 5 15 :+ SP 3 (),Point2 1 11 :+ SP 4 ()]

Finds the extreme points, minimum and maximum, in a given direction

running time: \(O(n)\)

Comparison that compares which point is larger in the direction given by the vector u.

Rotate to the first point that matches the given condition.

>>> toVector <$> findRotateTo (== (Point2 1 0 :+ ())) (unsafeFromPoints [Point2 0 0 :+ (), Point2 1 0 :+ (), Point2 1 1 :+ ()])
Just [Point2 1 0 :+ (),Point2 1 1 :+ (),Point2 0 0 :+ ()]
>>> findRotateTo (== (Point2 7 0 :+ ())) $ unsafeFromPoints [Point2 0 0 :+ (), Point2 1 0 :+ (), Point2 1 1 :+ ()]
Nothing