MutableAffineTransform

Kotlin |Java

class MutableAffineTransform : AffineTransform

kotlin.Any
↳	androidx.ink.geometry.AffineTransform
	↳	androidx.ink.geometry.MutableAffineTransform

An affine transformation in the plane. The transformation can be thought of as a 3x3 matrix:

⎡m00  m10  m20⎤
⎢m01  m11  m21⎥
⎣ 0    0    1 ⎦

Applying the transformation can be thought of as a matrix multiplication, with the to-be-transformed point represented as a column vector with an extra 1:

⎡m00  m10  m20⎤   ⎡x⎤   ⎡m00*x + m10*y + m20⎤
⎢m01  m11  m21⎥ * ⎢y⎥ = ⎢m01*x + m11*y + m21⎥
⎣ 0    0    1 ⎦   ⎣1⎦   ⎣         1         ⎦

Transformations are composed via multiplication. Multiplication is not commutative (i.e. AB != BA), and the left-hand transformation is composed "after" the right hand transformation. E.g., if you have:

val rotate = ImmutableAffineTransform.rotate(Angle.degreesToRadians(45))
val translate = ImmutableAffineTransform.translate(Vec(10, 0))

then rotate * translate first translates 10 units in the positive x-direction, then rotates 45° about the origin.

See ImmutableAffineTransform for an immutable alternative to this class.

Summary

Public constructors
`MutableAffineTransform()` Constructs an identity `MutableAffineTransform`:

Public functions
`open operator Boolean`	`equals(other: Any?)` Component-wise equality operator for `MutableAffineTransform`.
`open Int`	`hashCode()`
`Unit`	`setValues(values: @Size(min = 6) FloatArray)` Like `setValues`, but accepts a `FloatArray` instead of individual float values.
`Unit`	`setValues(m00: Float, m10: Float, m20: Float, m01: Float, m11: Float, m21: Float)` Populates this transform with the given values, starting with the top left corner of the matrix and proceeding in row-major order.
`open String`	`toString()`

Inherited functions

From androidx.ink.geometry.AffineTransform

`MutableParallelogram`	`applyTransform(box: Box, outParallelogram: MutableParallelogram)` Apply the `AffineTransform` to the `Box` and store the result in the `MutableParallelogram`.
`MutableParallelogram`	`applyTransform( parallelogram: Parallelogram, outParallelogram: MutableParallelogram )` Apply the `AffineTransform` to the `Parallelogram` and store the result in the `MutableParallelogram`.
`MutableVec`	`applyTransform(point: Vec, outVec: MutableVec)` Apply the `AffineTransform` to the `Vec` and store the result in the `MutableVec`.
`MutableSegment`	`applyTransform(segment: Segment, outSegment: MutableSegment)` Apply the `AffineTransform` to the `Segment` and store the result in the `MutableSegment`.
`MutableTriangle`	`applyTransform(triangle: Triangle, outTriangle: MutableTriangle)` Apply the `AffineTransform` to the `Triangle` and store the result in the `MutableTriangle`.
`MutableAffineTransform`	`computeInverse(outAffineTransform: MutableAffineTransform)` Populates `outAffineTransform` with the inverse of this `AffineTransform`.
`@Size(min = 6) FloatArray`	`getValues(outArray: @Size(min = 6) FloatArray)` Populates the first 6 elements of `outArray` with the values of this transform, starting with the top left corner of the matrix and proceeding in row-major order.

Public constructors

MutableAffineTransform

Added in 1.0.0-alpha02

MutableAffineTransform()

Constructs an identity MutableAffineTransform:

⎡1  0  0⎤
⎢0  1  0⎥
⎣0  0  1⎦

This is useful when pre-allocating a scratch instance to be filled later.

Public functions

equals

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

Component-wise equality operator for MutableAffineTransform.

Due to the propagation floating point precision errors, operations that may be equivalent over the real numbers are not always equivalent for floats, and might return false for equals in some cases.

hashCode

open fun hashCode(): Int

setValues

Added in 1.0.0-alpha02

fun setValues(values: @Size(min = 6) FloatArray): Unit

Like setValues, but accepts a FloatArray instead of individual float values.

setValues

Added in 1.0.0-alpha02

fun setValues(m00: Float, m10: Float, m20: Float, m01: Float, m11: Float, m21: Float): Unit

Populates this transform with the given values, starting with the top left corner of the matrix and proceeding in row-major order.

Prefer to modify this object with functions that apply specific transform operations, such as populateFromScale or populateFromRotate, rather than directly setting the actual numeric values of this transform. This function is useful for when the values are needed to be provided in bulk, for example for serialization.

To access these values in the same order as they are set here, use AffineTransform.getValues.

toString

open fun toString(): String