Creates a builder that is initialized with the current path and allows further modifications. The resulting path from that builder is different from the one then was called on.

Functions

circle

fun circle(center: Point, radius: Double, direction: RotationDirection): Path

Creates a circle path. The direction flag allows multiple circles to be combined to create circular holes. A ring can be created by joining an outer and inner circle with opposite directions.

lerp

fun lerp(first: Vector2D, second: Vector2D, fraction: Float): Vector2D

Interpolates between 2 points

fun lerp(first: Rectangle, second: Rectangle, fraction: Float): Rectangle

Interpolates between 2 Rectangles

fun lerp(first: Size, second: Size, fraction: Float): Size

Interpolates between 2 Sizes

path

fun path(from: Point): PathBuilder

Creates a Path at the given point and a builder to further define it.

fun path(data: String): Path?

Creates a Path from the path data string.

fun path(x: Double, y: Double): PathBuilder

Creates a Path at the given x,y and a builder to further define it.

ring

fun ring(center: Point, innerRadius: Double, outerRadius: Double): Path

Creates ring (donut) path.

ringSection

fun ringSection( center: Point, innerRadius: Double, outerRadius: Double, start: Measure<Angle>, end: Measure<Angle>, startCap: SegmentBuilder = { _,_ -> }, endCap: SegmentBuilder = { _,it -> lineTo(it) }): Path

Creates a path for a section of a ring (donut) shape. The direction of sweep is controlled by the sign of end - start.

semicircle

fun semicircle(center: Point, radius: Double, start: Measure<Angle>, end: Measure<Angle>): Path

Creates a path for a semicircle. The direction of sweep is controlled by the sign of end - start.

star

fun star(circle: Circle, points: Int = 5, rotation: Measure<Angle> = 0 * degrees, innerCircle: Circle): Polygon?

fun star(circle: Circle, points: Int = 5, rotation: Measure<Angle> = 0 * degrees, innerCircleRatio: Float = starDefaultInnerCircleRatio): Polygon?

Creates a Star with n points that is described by an outer and inner Circle, which its concave and convex points respectively.

fun star(circle: Circle, points: Int = 5, rotation: Measure<Angle> = 0 * degrees, innerCircle: Circle, pointRoundness: Float): Path?

fun star( circle: Circle, points: Int = 5, rotation: Measure<Angle> = 0 * degrees, innerCircleRatio: Float = starDefaultInnerCircleRatio, pointRoundness: Float): Path?

Creates a rounded star.

Inherited functions

fun Circle.at(point: Point): Circle

atOrigin

fun Circle.atOrigin(): Circle

centered

fun Rectangle.centered(at: Point): Rectangle

Returns a new Rectangle with the same size as this, but with its center moved to at.

coerceIn

fun Size.coerceIn(min: Size, max: Size): Size

div

operator fun Size.div(value: Double): Size

operator fun Size.div(value: Float): Size

operator fun Size.div(value: Int): Size

Returns a Size with width / value and height / value

inscribed

fun Ellipse.inscribed(sides: Int, rotation: Measure<Angle> = 0 * degrees): ConvexPolygon?

Creates a Regular polygon by inscribing it within the ellipse.

inscribedCircle

fun Rectangle.inscribedCircle(): Circle

Creates a Circle that is inscribed within the rectangle

inscribedEllipse

fun Rectangle.inscribedEllipse(): Ellipse

Creates an Ellipse that is inscribed within the rectangle

inset

fun Circle.inset(inset: Double): Circle

fun Ellipse.inset(insetX: Double, insetY: Double = insetX): Ellipse

fun Rectangle.inset(top: Double = 0.0, left: Double = 0.0, right: Double = 0.0, bottom: Double = 0.0): Rectangle

Rectangle that has been adjusted as follows [x + left, y + top, w - (left + right), h - (top + bottom)].

interiorAngle

infix fun Vector3D.interiorAngle(other: Vector3D): Measure<Angle>

Calculate the interior angle between 2 vectors =>angle := cos(α) = a·b / (|a|·|b|).

lineTo

fun PathBuilder.lineTo(x: Double, y: Double): PathBuilder

Draws a line from the current point to this one.

map

fun ConvexPolygon.map(transform: (Point) -> Point): ConvexPolygon

Create a new ConvexPolygon with each point transformed by transform.

moveTo

fun PathBuilder.moveTo(x: Double, y: Double): PathBuilder

Moves from the current point to this one.

reversed

fun ConvexPolygon.reversed(): ConvexPolygon

Create a new ConvexPolygon with the same points, but in reversed order.

rounded

fun Polygon.rounded(config: (index: Int, Point) -> Double): Path

fun Polygon.rounded(radius: Double, filter: (index: Int, Point) -> Boolean = { _,_ -> true }): Path

Creates a rounded shape from a Polygon. The resulting shape is essentially a polygon with the vertices rounded using a semicircular curve.

times

operator fun Size.times(value: Double): Size

operator fun Size.times(value: Float): Size

operator fun Double.times(value: Vector2D): Vector2D

operator fun Double.times(value: Vector3D): Vector3D

operator fun Float.times(value: Vector2D): Vector2D

operator fun Float.times(value: Vector3D): Vector3D

operator fun Int.times(value: Vector2D): Vector2D

operator fun Int.times(value: Vector3D): Vector3D

operator fun Size.times(value: Int): Size

Returns a Size with width * value and height * value

toPath

fun Ellipse.toPath(): Path

Converts an Ellipse to a Path.

fun Polygon.toPath(): Path

Converts a Polygon to a Path.

fun Rectangle.toPath(radius: Double): Path

Converts Rectangle with radius to Path.

fun Rectangle.toPath( topLeftRadius: Double = 0.0, topRightRadius: Double = 0.0, bottomRightRadius: Double = 0.0, bottomLeftRadius: Double = 0.0): Path

Converts Rectangle with radii to Path.

with

fun Rectangle.with(size: Size): Rectangle

Returns a new Rectangle with the specified size, and all the other dimensions from this one.

fun Rectangle.with(width: Double = this.width, height: Double = this.height): Rectangle

Returns a new Rectangle with the specified width, height, and all the other dimensions from this one.

withRadius

fun Circle.withRadius(radius: Double): Circle