MutableAffineTransform

Kotlin |Java

public final class MutableAffineTransform extends AffineTransform

java.lang.Object
↳	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 methods
`boolean`	`equals(Object other)` Component-wise equality operator for `MutableAffineTransform`.
`int`	`hashCode()`
`final @NonNull MutableAffineTransform`	`populateFrom(@NonNull AffineTransform input)` Fills this `MutableAffineTransform` with the same values contained in `input`.
`final @NonNull MutableAffineTransform`	`populateFromIdentity()` Fills this `MutableAffineTransform` with an identity transformation, which maps a point to itself, i.e. it leaves it unchanged.
`final @NonNull MutableAffineTransform`	`populateFromRotation(@AngleRadiansFloat float angleOfRotation)` Fills this `MutableAffineTransform` with a transformation that rotates by the given angle, centered about the origin.
`final @NonNull MutableAffineTransform`	`populateFromScale(float scaleFactor)` Fills this `MutableAffineTransform` with a transformation that scales in both the x and y direction by the given `scaleFactor`, centered about the origin.
`final @NonNull MutableAffineTransform`	`populateFromScale(float xScaleFactor, float yScaleFactor)` Fills this `MutableAffineTransform` with a transformation that scales in both the x- and y-direction by the given pair of factors; `xScaleFactor` and `yScaleFactor` respectively, centered about the origin.
`final @NonNull MutableAffineTransform`	`populateFromScaleX(float scaleFactor)` Fills this `MutableAffineTransform` with a transformation that scales in the x-direction by the given factor, centered about the origin.
`final @NonNull MutableAffineTransform`	`populateFromScaleY(float scaleFactor)` Fills this `MutableAffineTransform` with a transformation that scales in the y-direction by the given factor, centered about the origin.
`final @NonNull MutableAffineTransform`	`populateFromShearX(float shearFactor)` Fills this `MutableAffineTransform` with a transformation that shears in the x-direction by the given factor.
`final @NonNull MutableAffineTransform`	`populateFromShearY(float shearFactor)` Fills this `MutableAffineTransform` with a transformation that shears in the y-direction by the given factor.
`final @NonNull MutableAffineTransform`	`populateFromTranslate(@NonNull Vec offset)` Fills this `MutableAffineTransform` with a transformation that translates by the given `offset` vector.
`final void`	`setValues(@Size(min = 6) @NonNull float[] values)` Like `setValues`, but accepts a `FloatArray` instead of individual float values.
`final void`	`setValues(float m00, float m10, float m20, float m01, float m11, float m21)` Populates this transform with the given values, starting with the top left corner of the matrix and proceeding in row-major order.
`@NonNull String`	`toString()`

Extension functions
`final @NonNull MutableAffineTransform`	`AndroidGraphicsConverter.populateFrom( @NonNull MutableAffineTransform receiver, @NonNull Matrix matrix )` Fills this `MutableAffineTransform` with the values from `matrix`.

Inherited methods

From androidx.ink.geometry.AffineTransform

`final @NonNull ImmutableParallelogram`	`applyTransform(@NonNull Box box)` Returns an `ImmutableParallelogram` containing the result of applying the `AffineTransform` to `box`.
`final @NonNull ImmutableParallelogram`	`applyTransform(@NonNull Parallelogram parallelogram)` Returns an `ImmutableParallelogram` containing the result of applying the `AffineTransform` to `parallelogram`.
`final @NonNull ImmutableVec`	`applyTransform(@NonNull Vec point)` Returns an `ImmutableVec` containing the result of applying the `AffineTransform` to `point`.
`final @NonNull ImmutableSegment`	`applyTransform(@NonNull Segment segment)` Returns an `ImmutableSegment` containing the result of applying the `AffineTransform` to `segment`.
`final @NonNull ImmutableTriangle`	`applyTransform(@NonNull Triangle triangle)` Returns an `ImmutableTriangle` containing the result of applying the `AffineTransform` to `triangle`.
`final @NonNull MutableParallelogram`	`applyTransform( @NonNull Box box, @NonNull MutableParallelogram outParallelogram )` Apply the `AffineTransform` to the `Box` and store the result in the `MutableParallelogram`.
`final @NonNull MutableParallelogram`	`applyTransform( @NonNull Parallelogram parallelogram, @NonNull MutableParallelogram outParallelogram )` Apply the `AffineTransform` to the `Parallelogram` and store the result in the `MutableParallelogram`.
`final @NonNull MutableVec`	`applyTransform(@NonNull Vec point, @NonNull MutableVec outVec)` Apply the `AffineTransform` to the `Vec` and store the result in the `MutableVec`.
`final @NonNull MutableSegment`	`applyTransform( @NonNull Segment segment, @NonNull MutableSegment outSegment )` Apply the `AffineTransform` to the `Segment` and store the result in the `MutableSegment`.
`final @NonNull MutableTriangle`	`applyTransform( @NonNull Triangle triangle, @NonNull MutableTriangle outTriangle )` Apply the `AffineTransform` to the `Triangle` and store the result in the `MutableTriangle`.
`final @NonNull ImmutableAffineTransform`	`computeInverse()` Returns the inverse of the `AffineTransform`.
`final @NonNull MutableAffineTransform`	`computeInverse(@NonNull MutableAffineTransform outAffineTransform)` Populates `outAffineTransform` with the inverse of this `AffineTransform`.
`final @Size(min = 6) @NonNull float[]`	`getValues(@Size(min = 6) @NonNull float[] outArray)` 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.
`final boolean`	`isAlmostEqual( @NonNull AffineTransform other, @FloatRange(from = 0.0) float tolerance )` Compares this `AffineTransform` with `other`, and returns true if each component of the transform matrix is within `tolerance` of the corresponding component of `other`.

Public constructors

MutableAffineTransform

Added in 1.0.0-alpha06

public 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 methods

equals

public boolean equals(Object other)

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

public int hashCode()