Core/io.nacular.doodle.geometry/Rectangle

Rectangle

A rectangular ConvexPolygon with 4 sides at right-angles.

            x
    (0,0)  ──▶
          │
       y  ▼
              ┌──────────────────────────┐
              │                          │
              │                          │
              │                          │
              │                          │ height
              │                          │
              │                          │
              │                          │
              └──────────────────────────┘
                         width

Author

Nicholas Eddy

Types

Companion

object Companion

Properties

area

open override val area: Double

aspectRatio

val Rectangle.aspectRatio: Double

Ratio of Image width/height.

atOrigin

val atOrigin: Rectangle

Rectangle with the same width/height but positioned at 0,0

bottom

val bottom: Double

Bottom edge

boundingRectangle

open override val boundingRectangle: Rectangle

Gives the smallest Rectangle that fully contains this Polygon.

center

val center: Point

Point at the center of the rectangle

centroid

open val centroid: Point

centroid

val ConvexPolygon.centroid: Point

empty

open override val empty: Boolean

height

val height: Double

The vertical length

points

open override val points: List<Point>

Points representing the vertices

position

val position: Point

Top-left corner (x,y)

right

val right: Double

Right edge

signedArea

val signedArea: Double

size

val size: Size

width-height

width

val width: Double

The horizontal length

val x: Double

The left edge

val y: Double

The top edge

Functions

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

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.

contains

open operator override fun contains(point: Point): Boolean

Checks whether the given point is within the boundaries of this Rectangle

open operator override fun contains(rectangle: Rectangle): Boolean

equals

open operator override fun equals(other: Any?): Boolean

hashCode

open override fun hashCode(): Int

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

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

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.

intersects

open infix override fun intersects(rectangle: Rectangle): Boolean

Checks whether the given rectangle intersects this one

map

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

Create a new ConvexPolygon with each point transformed by transform.

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.

smooth

fun Rectangle.smooth(curvature: Float): Path

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

toPath

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.

toString

open override fun toString(): String

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.