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.

starDefaultInnerCircleRatio

val starDefaultInnerCircleRatio: Float

Functions

fun Circle.at(point: Point): Circle

infix fun Rectangle.at(position: Point): Rectangle

Returns a rectangle with the same width/height but positioned at the given point

fun Rectangle.at(x: Double = this.x, y: Double = this.y): Rectangle

Returns a rectangle with the same width/height but positioned at the given x,y

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.

fun Rectangle.centered(x: Double, y: Double): Rectangle

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

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.

coerceIn

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

coerceInAspect

fun Size.coerceInAspect(target: 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

infix fun Rectangle.inset(inset: Insets): Rectangle

Rectangle that has been adjusted as follows [x + left, y + top, w - (left + right), h - (top + bottom)], where the adjustments are from the inset

infix fun Rectangle.inset(inset: Double): Rectangle

Rectangle that has been adjusted as follows [x + i, y + i, w - 2i, h - 2i], where i is the inset

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|).

intersect

infix fun Rectangle.intersect(rectangle: Rectangle): Rectangle

Returns a Rectangle that is the intersection of this and the given one. The result is Empty if there is no intersection.

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

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.

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.

reversed

fun ConvexPolygon.reversed(): ConvexPolygon

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

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.

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.

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.

smooth

fun Rectangle.smooth(curvature: Float): Path

Creates a smooth Path resembling a superellipse based on this Rectangle.

squircle

fun squircle(at: Point = Origin, length: Double): Path

Creates a path based on a square with sides of length and smooth rounded corners.

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.

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.

union

infix fun Rectangle.union(rectangle: Rectangle): Rectangle

Returns a Rectangle that is the union of this and the given one.

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