#include <CUPath2.h>

Public Member Functions
	Path2 ()

	Path2 (const std::vector< Vec2 > &vertices)

	Path2 (const Vec2 *vertices, size_t vertsize)

	Path2 (const Path2 &path)

	Path2 (Path2 &&path)

	Path2 (const Rect rect)

	Path2 (const std::shared_ptr< JsonValue > &data)

	~Path2 ()

Path2 &	operator= (const Path2 &other)

Path2 &	operator= (Path2 &&other)

Path2 &	operator= (const Rect rect)

Path2 &	operator= (const std::shared_ptr< JsonValue > &data)

Path2 &	set (const std::vector< Vec2 > &vertices)

Path2 &	set (const Vec2 *vertices, size_t vertsize)

Path2 &	set (const Path2 &path)

Path2 &	set (const Rect rect)

Path2 &	set (const std::shared_ptr< JsonValue > &data)

Path2 &	clear ()

bool	empty () const

size_t	size () const

bool	isClosed () const

Vec2 &	at (size_t index)

const Vec2 &	at (size_t index) const

bool	isCorner (size_t index) const

const std::vector< Vec2 > &	getVertices () const

const Rect	getBounds () const

std::vector< Uint32 >	getIndices () const

size_t	getIndices (std::vector< Uint32 > &buffer) const

Vec2	pop ()

void	push (Vec2 point, bool corner=false)

void	push (float x, float y, bool corner=false)

Vec2	remove (size_t index)

void	add (size_t index, Vec2 point, bool corner=false)

void	add (size_t index, float x, float y, bool corner=false)

void	reserve (size_t size)

std::vector< Uint32 >	convexHull () const

bool	contains (Vec2 point) const

bool	contains (float x, float y) const

bool	incident (Vec2 point, float err=CU_MATH_EPSILON) const

bool	incident (float x, float y, float err=CU_MATH_EPSILON) const

Uint32	leftTurns () const

bool	isConvex () const

float	area () const

int	orientation () const

Path2 &	reverse ()

Path2	reversed () const

Path2 &	operator*= (float scale)

Path2 &	operator*= (const Vec2 scale)

Path2 &	operator*= (const Affine2 &transform)

Path2 &	operator*= (const Mat4 &transform)

Path2 &	operator/= (float scale)

Path2 &	operator/= (const Vec2 scale)

Path2 &	operator+= (const Vec2 offset)

Path2 &	operator-= (const Vec2 offset)

Path2	operator* (float scale) const

Path2	operator* (const Vec2 scale) const

Path2	operator* (const Affine2 &transform) const

Path2	operator* (const Mat4 &transform) const

Path2	operator/ (float scale) const

Path2	operator/ (const Vec2 scale) const

Path2	operator+ (const Vec2 offset) const

Path2	operator- (const Vec2 offset)

Path2 &	operator+= (const Path2 &extra)

Path2	operator+ (const Path2 &extra) const

Path2	slice (size_t start, size_t end) const

Path2	sliceFrom (size_t start) const

Path2	sliceTo (size_t end) const

std::string	toString (bool verbose=false) const

	operator std::string () const

	operator Rect () const

Static Public Member Functions
static std::vector< Uint32 >	convexHull (const std::vector< Vec2 > &vertices)

static int	orientation (const Vec2 &a, const Vec2 &b, const Vec2 &c)

static int	orientation (const std::vector< Vec2 > &path)

static int	orientation (const Vec2 *path, size_t size)

Public Attributes
std::vector< Vec2 >	vertices

std::unordered_set< size_t >	corners

bool	closed

Friends
class	PathSmoother

class	PathFactory

class	SplinePather

class	SimpleExtruder

class	ComplexExtruder

class	EarclipTriangulator

class	DelaunayTriangulator

Path2	operator* (float scale, const Path2 &path)

Path2	operator* (const Vec2 scale, const Path2 &path)

Detailed Description

Class to represent a flattened polyline.

This class is intended to represent any continuous polyline. While it may be either open or closed, it should not have any gaps between vertices. If you need a path with gaps, that should be represented by multiple Path2 objects.

It is possible to draw a path object directly to a SpriteBatch. However, in most applications you will want to convert a path object to a Poly2 for width and texturing. In particular, you will often want to either extrude (give stroke width) or triangulate (fill) a path.

We have provided several factories for converting a path to a Poly2. These factories allow for delegating index computation to a separate thread, if it takes too long. These factories are as follows:

EarclipTriangulator: This is a simple earclipping-triangulator for tesselating paths into polygons. It supports holes, but does not support self-intersections. While it produces better (e.g. less thin) triangles than MonotoneTriangulator, this comes at a cost. This triangulator has worst case O(n^2). With that said, it has low overhead and so is very efficient on small polygons.

DelaunayTriangulator: This is a Delaunay Triangular that gives a more uniform triangulation in accordance to the Vornoi diagram. This triangulator uses an advancing-front algorithm that is the fastest in practice (though worst case O(n log n) is not guaranteed). However, it has a lot of overhead that is unnecessary for small polygons. As with EarclipTriangulator, it supports holes, but does not support self-intersections.

PathFactory: This is a tool is used to generate several basic path shapes, such as rounded rectangles or arcs. It also allows you construct wireframe traversals of polygon meshes.

SimpleExtruder: This is a tool can take a path and convert it into a solid polygon. This solid polygon is the same as the path, except that the path now has a width and a mitre at the joints. This algorithm is quite fast, but the resulting polygon may overlap itself. This is ideal for strokes that only need to be drawn and do not need accurate geometric information.

ComplexExtruder: Like SimpleExtruder, this is a tool can take a path polygon and convert it into a solid polygon. However it is much more powerful and guarantees that the resulting polygon has no overlaps. Unforunately, it is extremely slow (in the 10s of milliseconds) and is unsuitable for calcuations at framerate.

Constructor & Destructor Documentation

◆ Path2() [1/7]

cugl::Path2::Path2 ( )

inline

Creates an empty path.

The created path has no vertices. The bounding box is trivial.

◆ Path2() [2/7]

cugl::Path2::Path2 ( const std::vector< Vec2 > & vertices )

inline

Creates a path with the given vertices

No vertices are marked are as corner vertices. The path will be open.

Parameters

vertices The vector of vertices (as Vec2) in this path

◆ Path2() [3/7]

cugl::Path2::Path2	(	const Vec2 *	vertices,
		size_t	vertsize
	)

inline

Creates a path with the given vertices

No vertices are marked are as corner vertices. The path will be open.

Parameters

vertices	The array of vertices in this path
vertsize	The number of elements to use from vertices

◆ Path2() [4/7]

cugl::Path2::Path2 ( const Path2 & path )

inline

Creates a copy of the given path.

Both the vertices and the annotations are copied. No references to the original path are kept.

Parameters

path	The path to copy

◆ Path2() [5/7]

cugl::Path2::Path2 ( Path2 && path )

inline

Creates a copy with the resource of the given path.

As a move constructor, this will invalidate the original path

Parameters

path	The path to take from

◆ Path2() [6/7]

cugl::Path2::Path2 ( const Rect rect )

inline

Creates a path for the given rectangle.

The path will have four vertices, one for each corner of the rectangle. It will be closed.

Parameters

rect	The rectangle to copy

◆ Path2() [7/7]

cugl::Path2::Path2 ( const std::shared_ptr< JsonValue > & data )

inline

Creates a path from the given JsonValue

The JsonValue should either be an array of floats or an JSON object. If it is an array of floats, then it interprets those floats as the vertices. All points are corners and the path is closed.

On the other hand, if it is a JSON object, it supports the following attributes:

"vertices":  An (even) list of floats, representing the vertices
"corners":   A list of integers representing corner positions
"closed":    A boolean value, representing if the path is closed

All attributes are optional. If "vertices" are missing, then the path will be empty. If "corners" is missing, then all vertices are corners. If "closed" is missing, then the path is closed by default.

Parameters

data	The JSON object specifying the path

◆ ~Path2()

cugl::Path2::~Path2 ( )

inline

Deletes the given path, freeing all resources.

Member Function Documentation

◆ add() [1/2]

void cugl::Path2::add	(	size_t	index,
		float	x,
		float	y,
		bool	corner = `false`
	)

Adds a point at the given index

Parameters

index	The index to add the point
x	The x-coordinate to add
y	The y-coordinate to add
corner	Whether this point is a corner

◆ add() [2/2]

void cugl::Path2::add	(	size_t	index,
		Vec2	point,
		bool	corner = `false`
	)

Adds a point at the given index

Parameters

index	The index to add the point
point	The point to add
corner	Whether this point is a corner

◆ area()

float cugl::Path2::area ( ) const

Returns the area enclosed by this path.

The area is defined as the sum of oriented triangles in a triangle fan from a point on the convex hull. Counter-clockwise triangles have positive area, while clockwise triangles have negative area. The result agrees with the traditional concept of area for counter clockwise paths.

The area can be used to determine the orientation. It the area is negative, that means this path essentially represents a hole (e.g. is clockwise instead of counter-clockwise).

Returns: the area enclosed by this path.

◆ at() [1/2]

Vec2 & cugl::Path2::at ( size_t index )

inline

Returns a reference to the point at the given index.

This accessor will allow you to change the (singular) point. It is intended to allow minor distortions to the path without changing the underlying geometry.

Parameters

index The path index

Returns: a reference to the point at the given index.

◆ at() [2/2]

const Vec2 & cugl::Path2::at ( size_t index ) const

inline

Returns a reference to the point at the given index.

This accessor will allow you to change the (singular) point. It is intended to allow minor distortions to the path without changing the underlying geometry.

Parameters

index The path index

Returns: a reference to the point at the given index.

◆ clear()

Path2 & cugl::Path2::clear ( )

Clears the contents of this path

Returns: This path, returned for chaining

◆ contains() [1/2]

bool cugl::Path2::contains	(	float	x,
		float	y
	)		const

Returns true if the interior of this path contains the given point.

This mehtod returns false if the path is open. Otherwise, it uses an even-odd crossing rule to determine containment. Containment is not strict. Points on the boundary are contained within this polygon.

Parameters

x	The x-coordinate to test
y	The y-coordinate to test

Returns: true if this path contains the given point.

◆ contains() [2/2]

bool cugl::Path2::contains ( Vec2 point ) const

inline

Returns true if the interior of this path contains the given point.

This mehtod returns false if the path is open. Otherwise, it uses an even-odd crossing rule to determine containment. Containment is not strict. Points on the boundary are contained within this polygon.

Parameters

point The point to test

Returns: true if this path contains the given point.

◆ convexHull() [1/2]

std::vector< Uint32 > cugl::Path2::convexHull ( ) const

Returns the set of points forming the convex hull of this path.

The returned set of points is guaranteed to be a counter-clockwise traversal of the hull.

The points on the convex hull define the "border" of the shape. In addition to minimizing the number of vertices, this is useful for determining whether or not a point lies on the boundary.

This implementation is adapted from the example at

http://www.geeksforgeeks.org/convex-hull-set-2-graham-scan/

Returns: the set of points forming the convex hull of this polygon.

◆ convexHull() [2/2]

static std::vector< Uint32 > cugl::Path2::convexHull ( const std::vector< Vec2 > & vertices )

static

Returns the set of points forming the convex hull of the given points.

The returned set of points is guaranteed to be a counter-clockwise traversal of the hull.

The points on the convex hull define the "border" of the shape. In addition to minimizing the number of vertices, this is useful for determining whether or not a point lies on the boundary.

This implementation is adapted from the example at

http://www.geeksforgeeks.org/convex-hull-set-2-graham-scan/

Parameters

vertices The points for the computation

Returns: the set of points forming the convex hull of the given points.

◆ empty()

bool cugl::Path2::empty ( ) const

inline

Returns true if the path is empty.

Returns: true if the path is empty.

◆ getBounds()

const Rect cugl::Path2::getBounds ( ) const

Returns the bounding box for the path

The bounding box is the minimal rectangle that contains all of the vertices in this path. This method will recompute the bounds and is hence O(n).

Returns: the bounding box for the path

◆ getIndices() [1/2]

std::vector< Uint32 > cugl::Path2::getIndices ( ) const

Returns a list of vertex indices representing this path.

The indices are intended to be used in a drawing mesh to display this path. The number of indices will be a multiple of two.

Returns: a list of vertex indices for using in a path mesh.

◆ getIndices() [2/2]

size_t cugl::Path2::getIndices ( std::vector< Uint32 > & buffer ) const

Stores a list of vertex indices in the given buffer.

The indices are intended to be used in a drawing mesh to display this path. The number of indices will be a multiple of two.

The indices will be appended to the provided vector. You should clear the vector first if you do not want to preserve the original data. If the calculation is not yet performed, this method will do nothing.

Parameters

buffer a buffer to store the list of indices.

Returns: the number of elements added to the buffer

◆ getVertices()

const std::vector< Vec2 > & cugl::Path2::getVertices ( ) const

inline

Returns the list of vertices

This accessor will not permit any changes to the vertex array. To change the array, you must change the path via a set() method.

Returns: a reference to the vertex array

◆ incident() [1/2]

bool cugl::Path2::incident	(	float	x,
		float	y,
		float	err = `CU_MATH_EPSILON`
	)		const

Returns true if the given point is on the path.

This method returns true if the point is within margin of error of a line segment.

Parameters

x	The x-coordinate to test
y	The y-coordinate to test
err	The distance tolerance

Returns: true if the given point is on the path.

◆ incident() [2/2]

bool cugl::Path2::incident	(	Vec2	point,
		float	err = `CU_MATH_EPSILON`
	)		const

inline

Returns true if the given point is on the path.

This method returns true if the point is within margin of error of a line segment.

Parameters

point	The point to check
err	The distance tolerance

Returns: true if the given point is on the path.

◆ isClosed()

bool cugl::Path2::isClosed ( ) const

inline

Returns whether the path is closed.

Returns: whether the path is closed.

◆ isConvex()

bool cugl::Path2::isConvex ( ) const

Returns true if this path defines a convex shape.

This method returns false if the path is open.

Returns: true if this path defines a convex shape.

◆ isCorner()

bool cugl::Path2::isCorner ( size_t index ) const

Returns true if the point at the given index is a corner

Corner points will be assigned a joint style when extruded. Points that are not corners will be extruded smoothly (typically because they are the result of a bezier expansion).

Parameters

index The attribute index

Returns: true if the point at the given index is a corner

◆ leftTurns()

Uint32 cugl::Path2::leftTurns ( ) const

Returns the number of left turns in this path.

Left turns are determined by looking at the interior angle generated at each point (assuming that the path is intended to be counterclockwise). In the case of an open path, the first and last vertexes are not counted.

This method is a generalization of isConvex that can be used to analyze the convexity of a path.

Returns: true if this path defines a convex shape.

◆ operator Rect()

cugl::Path2::operator Rect ( ) const

Cast from Path2 to a Rect.

◆ operator std::string()

cugl::Path2::operator std::string ( ) const

inline

Cast from Path2 to a string.

◆ operator*() [1/4]

Path2 cugl::Path2::operator* ( const Affine2 & transform ) const

inline

Returns a new path by transforming all of the vertices of this path.

Note: This method does not modify the path.

Parameters

transform The affine transform

Returns: The transformed path

◆ operator*() [2/4]

Path2 cugl::Path2::operator* ( const Mat4 & transform ) const

inline

Returns a new path by transforming all of the vertices of this path.

The vertices are transformed as 3d points. The z-value is 0.

Note: This method does not modify the path.

Parameters

transform The transform matrix

Returns: The transformed path

◆ operator*() [3/4]

Path2 cugl::Path2::operator* ( const Vec2 scale ) const

inline

Returns a new path by scaling the vertices non-uniformly.

The vertices are scaled from the origin of the coordinate space. This means that if the origin is not path of this path, then the path will be effectively translated by the scaling.

Note: This method does not modify the path.

Parameters

scale The non-uniform scaling factor

Returns: The scaled path

◆ operator*() [4/4]

Path2 cugl::Path2::operator* ( float scale ) const

inline

Returns a new path by scaling the vertices uniformly.

The vertices are scaled from the origin of the coordinate space. This means that if the origin is not path of this path, then the path will be effectively translated by the scaling.

Note: This method does not modify the path.

Parameters

scale The uniform scaling factor

Returns: The scaled path

◆ operator*=() [1/4]

Path2 & cugl::Path2::operator*= ( const Affine2 & transform )

Transforms all of the vertices of this path.

Parameters

transform The affine transform

Returns: This path with the vertices transformed

◆ operator*=() [2/4]

Path2 & cugl::Path2::operator*= ( const Mat4 & transform )

Transforms all of the vertices of this path.

The vertices are transformed as 3d points. The z-value is 0.

Parameters

transform The transform matrix

Returns: This path with the vertices transformed

◆ operator*=() [3/4]

Path2 & cugl::Path2::operator*= ( const Vec2 scale )

Nonuniformly scales all of the vertices of this path.

The vertices are scaled from the origin of the coordinate space. This means that if the origin is not path of this path, then the path will be effectively translated by the scaling.

Parameters

scale The non-uniform scaling factor

Returns: This path, scaled non-uniformly.

◆ operator*=() [4/4]

Path2 & cugl::Path2::operator*= ( float scale )

Uniformly scales all of the vertices of this path.

The vertices are scaled from the origin of the coordinate space. This means that if the origin is not path of this path, then the path will be effectively translated by the scaling.

Parameters

scale The uniform scaling factor

Returns: This path, scaled uniformly.

◆ operator+() [1/2]

Path2 cugl::Path2::operator+ ( const Path2 & extra ) const

inline

Returns a new path by appending extra to the end of this path

The vertices are appended in order to the end of the path. If the original path was closed, the copy is open (regardless of whether or not extra is closed)

Note: This method does not modify the original path.

Parameters

extra The path to add

Returns: The extended path

◆ operator+() [2/2]

Path2 cugl::Path2::operator+ ( const Vec2 offset ) const

inline

Returns a new path by translating the vertices

Note: This method does not modify the path.

Parameters

offset The translation amount

Returns: The translated path

◆ operator+=() [1/2]

Path2 & cugl::Path2::operator+= ( const Path2 & extra )

Appends the given path to the end of this one

The vertices are appended in order to the end of the path. If the original path was closed, it is now open (regardless of whether or not extra is closed)

Parameters

extra The path to append

Returns: This path, extended.

◆ operator+=() [2/2]

Path2 & cugl::Path2::operator+= ( const Vec2 offset )

Translates all of the vertices of this path.

Parameters

offset The translation amount

Returns: This path, translated.

◆ operator-()

Path2 cugl::Path2::operator- ( const Vec2 offset )

inline

Returns a new path by translating the vertices

Note: This method does not modify the path.

Parameters

offset The inverse of the translation amount

Returns: The translated path

◆ operator-=()

Path2 & cugl::Path2::operator-= ( const Vec2 offset )

Translates all of the vertices of this path.

Parameters

offset The inverse of the translation amount

Returns: This path, translated

◆ operator/() [1/2]

Path2 cugl::Path2::operator/ ( const Vec2 scale ) const

inline

Returns a new path by scaling the vertices non-uniformly.

The vertices are scaled from the origin of the coordinate space. This means that if the origin is not path of this path, then the path will be effectively translated by the scaling.

Note: This method does not modify the path.

Parameters

scale The inverse of the non-uniform scaling factor

Returns: The scaled path

◆ operator/() [2/2]

Path2 cugl::Path2::operator/ ( float scale ) const

inline

Returns a new path by scaling the vertices uniformly.

The vertices are scaled from the origin of the coordinate space. This means that if the origin is not path of this path, then the path will be effectively translated by the scaling.

Note: This method does not modify the path.

Parameters

scale The inverse of the uniform scaling factor

Returns: The scaled path

◆ operator/=() [1/2]

Path2 & cugl::Path2::operator/= ( const Vec2 scale )

Nonuniformly scales all of the vertices of this path.

The vertices are scaled from the origin of the coordinate space. This means that if the origin is not path of this path, then the path will be effectively translated by the scaling.

Parameters

scale The inverse of the non-uniform scaling factor

Returns: This path, scaled non-uniformly.

◆ operator/=() [2/2]

Path2 & cugl::Path2::operator/= ( float scale )

Uniformly scales all of the vertices of this path.

The vertices are scaled from the origin of the coordinate space. This means that if the origin is not path of this path, then the path will be effectively translated by the scaling.

Parameters

scale The inverse of the uniform scaling factor

Returns: This path, scaled uniformly.

◆ operator=() [1/4]

Path2 & cugl::Path2::operator= ( const Path2 & other )

inline

Sets this path to be a copy of the given one.

All of the contents are copied, so that this path does not hold any references to elements of the other path.

This method returns a reference to this path for chaining.

Parameters

other The path to copy

Returns: This path, returned for chaining

◆ operator=() [2/4]

Path2 & cugl::Path2::operator= ( const Rect rect )

inline

Sets this path to be a copy of the given rectangle.

The path will have four vertices, one for each corner of the rectangle. The path will be closed.

This method returns a reference to this path for chaining.

Parameters

rect	The rectangle to copy

Returns: This path, returned for chaining

◆ operator=() [3/4]

Path2 & cugl::Path2::operator= ( const std::shared_ptr< JsonValue > & data )

inline

Sets this path from the data in the given JsonValue

The JsonValue should either be an array of floats or an JSON object. If it is an array of floats, then it interprets those floats as the vertices. All points are corners and the path is closed.

On the other hand, if it is a JSON object, it supports the following attributes:

"vertices":  An (even) list of floats, representing the vertices
"corners":   A list of integers representing corner positions
"closed":    A boolean value, representing if the path is closed

All attributes are optional. If "vertices" are missing, then the path will be empty. If "corners" is missing, then all vertices are corners. If "closed" is missing, then the path is closed by default.

Parameters

data	The JSON object specifying the path

Returns: This path, returned for chaining

◆ operator=() [4/4]

Path2 & cugl::Path2::operator= ( Path2 && other )

inline

Sets this path to be have the resources of the given one.

This method returns a reference to this path for chaining.

Parameters

other The path to take from

Returns: This path, returned for chaining

◆ orientation() [1/4]

int cugl::Path2::orientation ( ) const

Returns -1, 0, or 1 indicating the path orientation.

If the method returns -1, this is a counter-clockwise path. If 1, it is a clockwise path. If 0, that means it is undefined. The orientation can be undefined if all the points are colinear.

Returns: -1, 0, or 1 indicating the path orientation.

◆ orientation() [2/4]

static int cugl::Path2::orientation ( const std::vector< Vec2 > & path )

static

Returns -1, 0, or 1 indicating the path orientation.

If the method returns -1, this is a counter-clockwise path. If 1, it is a clockwise path. If 0, that means it is undefined. The orientation can be undefined if all the points are colinear.

Parameters

path	The path to check

Returns: -1, 0, or 1 indicating the path orientation.

◆ orientation() [3/4]

static int cugl::Path2::orientation	(	const Vec2 &	a,
		const Vec2 &	b,
		const Vec2 &	c
	)

static

Returns -1, 0, or 1 indicating the orientation of a -> b -> c

If the function returns -1, this is a counter-clockwise turn. If 1, it is a clockwise turn. If 0, it is colinear.

Parameters

a	The first point
b	The second point
c	The third point

Returns: -1, 0, or 1 indicating the orientation of a -> b -> c

◆ orientation() [4/4]

static int cugl::Path2::orientation	(	const Vec2 *	path,
		size_t	size
	)

static

Returns -1, 0, or 1 indicating the path orientation.

If the method returns -1, this is a counter-clockwise path. If 1, it is a clockwise path. If 0, that means it is undefined. The orientation can be undefined if all the points are colinear.

Parameters

path	The path to check
size	The path size

Returns: -1, 0, or 1 indicating the path orientation.

◆ pop()

Vec2 cugl::Path2::pop ( )

Returns the former end point in the path, after removing it

If this path is empty, this will return the zero vector.

Returns: the former end point in the path

◆ push() [1/2]

void cugl::Path2::push	(	float	x,
		float	y,
		bool	corner = `false`
	)

Adds a point to the end of this path

Parameters

x	The x-coordinate to add
y	The y-coordinate to add
corner	Whether this point is a corner

◆ push() [2/2]

void cugl::Path2::push	(	Vec2	point,
		bool	corner = `false`
	)

Adds a point to the end of this path

Parameters

point	The point to add
corner	Whether this point is a corner

◆ remove()

Vec2 cugl::Path2::remove ( size_t index )

Returns the former point at the given index, after removing it

If this path is empty, this will return the zero vector.

Returns: the former point at the given index

◆ reserve()

void cugl::Path2::reserve ( size_t size )

Allocates space in this path for the given number of points.

This method can help performance when a path is being constructed piecemeal.

Parameters

size	The number of spots allocated for future points.

◆ reverse()

Path2 & cugl::Path2::reverse ( )

Reverses the orientation of this path in place

The path will have all of its vertices in the reverse order from the original. This path will not be affected.

Returns: This path, returned for chaining

◆ reversed()

Path2 cugl::Path2::reversed ( ) const

Returns a path with the reverse orientation of this one.

The path will have all of its vertices in the reverse order from the original. This path will not be affected.

Returns: a path with the reverse orientation of this one.

◆ set() [1/5]

Path2 & cugl::Path2::set ( const Path2 & path )

Sets this path to be a copy of the given one.

All of the contents are copied, so that this path does not hold any references to elements of the other path.

This method returns a reference to this path for chaining.

Parameters

path	The path to copy

Returns: This path, returned for chaining

◆ set() [2/5]

Path2 & cugl::Path2::set ( const Rect rect )

Sets the path to represent the given rectangle.

The path will have four vertices, one for each corner of the rectangle. The path will be closed.

This method returns a reference to this path for chaining.

Parameters

rect	The rectangle to copy

Returns: This path, returned for chaining

◆ set() [3/5]

Path2 & cugl::Path2::set ( const std::shared_ptr< JsonValue > & data )

Sets this path from the data in the given JsonValue

The JsonValue should either be an array of floats or an JSON object. If it is an array of floats, then it interprets those floats as the vertices. All points are corners and the path is closed.

On the other hand, if it is a JSON object, it supports the following attributes:

"vertices":  An (even) list of floats, representing the vertices
"corners":   A list of integers representing corner positions
"closed":    A boolean value, representing if the path is closed

All attributes are optional. If "vertices" are missing, then the path will be empty. If "corners" is missing, then all vertices are corners. If "closed" is missing, then the path is closed by default.

Parameters

data	The JSON object specifying the path

Returns: This path, returned for chaining

◆ set() [4/5]

Path2 & cugl::Path2::set ( const std::vector< Vec2 > & vertices )

Sets the path to have the given vertices

No vertices are marked are as corner vertices. The path will be open.

This method returns a reference to this path for chaining.

Parameters

vertices The vector of vertices (as Vec2) in this path

Returns: This path, returned for chaining

◆ set() [5/5]

Path2 & cugl::Path2::set	(	const Vec2 *	vertices,
		size_t	vertsize
	)

Sets the path to have the given vertices.

No vertices are marked are as corner vertices. The path will be open.

This method returns a reference to this path for chaining.

Parameters

vertices	The array of vertices in this path
vertsize	The number of elements to use from vertices

Returns: This path, returned for chaining

◆ size()

size_t cugl::Path2::size ( ) const

inline

Returns the number of vertices in a path.

Returns: the number of vertices in a path.

◆ slice()

Path2 cugl::Path2::slice	(	size_t	start,
		size_t	end
	)		const

Returns the slice of this path between start and end.

The sliced path will use the indices from start to end (not including end). It will include the vertices referenced by those indices, and only those vertices. The resulting path is open.

Parameters

start	The start index
end	The end index

Returns: the slice of this mesh between start and end.

◆ sliceFrom()

Path2 cugl::Path2::sliceFrom ( size_t start ) const

inline

Returns the slice of this mesh from the start index to the end.

The sliced mesh will use the indices from start to the end. It will include the vertices referenced by those indices, and only those vertices. The resulting path is open.

Parameters

start The start index

Returns: the slice of this mesh between start and end.

◆ sliceTo()

Path2 cugl::Path2::sliceTo ( size_t end ) const

inline

Returns the slice of this mesh from the begining to end.

The sliced mesh will use the indices up to (but not including) end. It will include the vertices referenced by those indices, and only those vertices. The resulting path is open.

Parameters

end	The end index

Returns: the slice of this mesh between start and end.

◆ toString()

std::string cugl::Path2::toString ( bool verbose = false ) const

Returns a string representation of this path for debugging purposes.

If verbose is true, the string will include class information. This allows us to unambiguously identify the class.

Parameters

verbose Whether to include class information

Returns: a string representation of this path for debugging purposes.

Friends And Related Function Documentation

◆ operator* [1/2]

Path2 operator*	(	const Vec2	scale,
		const Path2 &	path
	)

friend

Returns a new path by scaling the vertices non-uniformly.

The vertices are scaled from the origin of the coordinate space. This means that if the origin is not path of this path, then the path will be effectively translated by the scaling.

Parameters

scale	The non-uniform scaling factor
path	The path to scale

Returns: The scaled path

◆ operator* [2/2]

Path2 operator*	(	float	scale,
		const Path2 &	path
	)

friend

Returns a new path by scaling the vertices uniformly.

The vertices are scaled from the origin of the coordinate space. This means that if the origin is not path of this path, then the path will be effectively translated by the scaling.

Parameters

scale	The uniform scaling factor
path	The path to scale

Returns: The scaled path

◆ PathSmoother

friend class PathSmoother

friend

Friend classes

Member Data Documentation

◆ closed

bool cugl::Path2::closed

Whether or not this path is closed

◆ corners

std::unordered_set<size_t> cugl::Path2::corners

The corner points of this path (used for extrusion).

◆ vertices

std::vector<Vec2> cugl::Path2::vertices

The vector of vertices in this path

The documentation for this class was generated from the following file:

cugl/include/cugl/math/CUPath2.h

Public Member Functions

Static Public Member Functions

Public Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ Path2() [1/7]

◆ Path2() [2/7]

◆ Path2() [3/7]

◆ Path2() [4/7]

◆ Path2() [5/7]

◆ Path2() [6/7]

◆ Path2() [7/7]

◆ ~Path2()

Member Function Documentation

◆ add() [1/2]

◆ add() [2/2]

◆ area()

◆ at() [1/2]

◆ at() [2/2]

◆ clear()

◆ contains() [1/2]

◆ contains() [2/2]

◆ convexHull() [1/2]

◆ convexHull() [2/2]

◆ empty()

◆ getBounds()

◆ getIndices() [1/2]

◆ getIndices() [2/2]

◆ getVertices()

◆ incident() [1/2]

◆ incident() [2/2]

◆ isClosed()

◆ isConvex()

◆ isCorner()

◆ leftTurns()

◆ operator Rect()

◆ operator std::string()

◆ operator*() [1/4]

◆ operator*() [2/4]

◆ operator*() [3/4]

◆ operator*() [4/4]

◆ operator*=() [1/4]

◆ operator*=() [2/4]

◆ operator*=() [3/4]

◆ operator*=() [4/4]

◆ operator+() [1/2]

◆ operator+() [2/2]

◆ operator+=() [1/2]

◆ operator+=() [2/2]

◆ operator-()

◆ operator-=()

◆ operator/() [1/2]

◆ operator/() [2/2]

◆ operator/=() [1/2]

◆ operator/=() [2/2]

◆ operator=() [1/4]

◆ operator=() [2/4]

◆ operator=() [3/4]

◆ operator=() [4/4]

◆ orientation() [1/4]

◆ orientation() [2/4]

◆ orientation() [3/4]

◆ orientation() [4/4]

◆ pop()

◆ push() [1/2]

◆ push() [2/2]

◆ remove()

◆ reserve()

◆ reverse()

◆ reversed()

◆ set() [1/5]

◆ set() [2/5]

◆ set() [3/5]

◆ set() [4/5]

◆ set() [5/5]

◆ size()

◆ slice()

◆ sliceFrom()

◆ sliceTo()