core/io.nacular.doodle.drawing/AffineTransform2D

AffineTransform2D

abstract class AffineTransform2D : AffineTransform

Represents an Affine Transformation that supports only 2D.

Types

object Companion

Properties

abstract override val inverse: AffineTransform2D?

Inherited properties

val isIdentity: Boolean

true if this transform is equal to the Identity transform

val scaleX: Double

Scale component in the x direction

val scaleY: Double

Scale component in the y direction

val scaleZ: Double

Scale component in the z direction

val shearX: Double

Shear component in the x direction

val shearXY: Double

Shear component in the x direction with z unchanged

val shearXZ: Double

Shear component in the x direction with y unchanged

val shearY: Double

Shear component in the y direction

val shearYX: Double

Shear component in the y direction with z unchanged

val shearYZ: Double

Shear component in the y direction with y unchanged

val shearZX: Double

Shear component in the z direction with x unchanged

val shearZY: Double

Shear component in the z direction with y unchanged

val translateX: Double

Translation component in the x direction

val translateY: Double

Translation component in the y direction

val translateZ: Double

Translation component in the z direction

Functions

flipHorizontally

open override fun flipHorizontally(): AffineTransform2D

Applies a horizontal flip operation (around the y-axis) to this transform.

open override fun flipHorizontally(at: Double): AffineTransform2D

Applies a horizontal flip operation to this transform.

open override fun flipVertically(): AffineTransform2D

Applies a vertical flip operation (around the x-axis) to this transform.

open override fun flipVertically(at: Double): AffineTransform2D

Applies a vertical flip operation to this transform.

abstract operator fun invoke(vararg points: Point): List<Point>

Transforms the given points.

abstract infix override fun rotate(by: Measure<Angle>): AffineTransform2D

Appends a rotation operation (around the z-axis), at the Origin to this transform.

open override fun rotate(around: Point, by: Measure<Angle>): AffineTransform2D

Appends a rotation (around the z-axis) operation to this transform.

abstract fun scale(x: Double = 1.0, y: Double = 1.0): AffineTransform2D

Append a scale operation (around the Origin) to this transform.

fun scale(around: Point, x: Double = 1.0, y: Double = 1.0): AffineTransform2D

Append a scale operation to this transform, that scales around the given point.

abstract fun skew(x: Double = 0.0, y: Double = 0.0): AffineTransform2D

Append a skew operation to this transform.

abstract operator fun times(other: AffineTransform2D): AffineTransform2D

Allows transforms to be combined sequentially.

open infix override fun translate(by: Point): AffineTransform2D

abstract fun translate(x: Double = 0.0, y: Double = 0.0): AffineTransform2D

Append a translation operation to this transform.

Inherited functions

fun AffineTransform2D.computeAngle(): Measure<Angle>

Return the angle this transform would apply.

operator fun invoke(polygon: ConvexPolygon): ConvexPolygon

Transforms the given polygon. Note that the resulting polygon is a 2D projection of the transformed points. That is because this transform may map the 2D points of polygon into a set of 3D points.

abstract operator fun invoke(point: Point): Vector3D

abstract fun invoke(point: Vector3D): Vector3D

Applies the transform to point. This operation treats point as a (3x1 or 4x1) Matrix (based on whether this is a 2D or 3D transform) and uses matrix multiplication to find a new 3x1 matrix to produce the result.

abstract operator fun invoke(vararg points: Vector3D): List<Vector3D>

Transforms the given points.

@JvmName(name = "callPoint")

inline fun AffineTransform.invoke(points: List<Point>): List<Vector3D>

inline fun AffineTransform.invoke(points: List<Vector3D>): List<Vector3D>

@JvmName(name = "callPoint")

inline fun AffineTransform2D.invoke(points: List<Point>): List<Point>

inline fun AffineTransform2D.invoke(points: List<Vector3D>): List<Vector3D>

Transforms the given points.

fun rotate(around: Vector3D, by: Measure<Angle>): AffineTransform

Appends a rotation (around the z-axis) operation to this transform.

abstract infix fun rotateX(by: Measure<Angle>): AffineTransform

Appends a rotation operation (around the x-axis), at the Origin to this transform.

fun rotateX(around: Point, by: Measure<Angle>): AffineTransform

fun rotateX(around: Vector3D, by: Measure<Angle>): AffineTransform

Appends a rotation (around the x-axis) operation to this transform.

abstract infix fun rotateY(by: Measure<Angle>): AffineTransform

fun rotateY(around: Point, by: Measure<Angle>): AffineTransform

fun rotateY(around: Vector3D, by: Measure<Angle>): AffineTransform

Appends a rotation (around the y-axis) operation to this transform.

abstract infix fun rotateZ(by: Measure<Angle>): AffineTransform

Appends a rotation operation (around the z-axis), at the Origin to this transform.

fun rotateZ(around: Point, by: Measure<Angle>): AffineTransform

fun rotateZ(around: Vector3D, by: Measure<Angle>): AffineTransform

Appends a rotation (around the z-axis) operation to this transform.

abstract fun scale(x: Double = 1.0, y: Double = 1.0, z: Double = 1.0): AffineTransform

Append a scale operation (around the Origin) to this transform.

fun scale(around: Point, x: Double = 1.0, y: Double = 1.0, z: Double = 1.0): AffineTransform

Append a scale operation to this transform, that scales around the given point.

fun scale(around: Vector3D, x: Double = 1.0, y: Double = 1.0, z: Double = 1.0): AffineTransform

abstract fun skew(x: Double = 0.0, y: Double = 0.0, z: Double = 0.0): AffineTransform

Append a skew operation to this transform.

abstract operator fun times(other: AffineTransform): AffineTransform

Allows transforms to be combined sequentially.

operator fun AffineTransform.times(transform: ProjectionTransform): ProjectionTransform

operator fun AffineTransform2D.times(transform: ProjectionTransform): ProjectionTransform

infix fun translate(by: Vector3D): AffineTransform

abstract fun translate(x: Double = 0.0, y: Double = 0.0, z: Double = 0.0): AffineTransform

Append a translation operation to this transform.