AffineTransform

public static final @NonNull ImmutableAffineTransform IDENTITY

Constant representing an identity transformation, which maps a point to itself, i.e. it leaves it unchanged.

public final @NonNull ImmutableParallelogram applyTransform(@NonNull Box box)

Returns an ImmutableParallelogram containing the result of applying the AffineTransform to box.

Note that applying an AffineTransform to a Box results in a Parallelogram. If you need a Box, use Parallelogram.computeBoundingBox to get the minimum bounding box of the result.

Performance-sensitive code should use the applyTransform overload that takes a pre-allocated MutableParallelogram, so that instance can be reused across multiple calls.

public final @NonNull ImmutableParallelogram applyTransform(@NonNull Parallelogram parallelogram)

Returns an ImmutableParallelogram containing the result of applying the AffineTransform to parallelogram.

Performance-sensitive code should use the applyTransform overload that takes a pre-allocated MutableParallelogram, so that instance can be reused across multiple calls.

public final @NonNull ImmutableVec applyTransform(@NonNull Vec point)

Returns an ImmutableVec containing the result of applying the AffineTransform to point.

Note that this treats point as a location, not an offset. If you want to transform an offset, you must also transform the origin and subtract that from the result, e.g.:

val result = MutableVec()
Vec.subtract(
  transform.applyTransform(vec),
  transform.applyTransform(Vec.ORIGIN),
  result
)

Performance-sensitive code should use the applyTransform overload that takes a pre-allocated MutableVec, so that instance can be reused across multiple calls.

public final @NonNull ImmutableSegment applyTransform(@NonNull Segment segment)

Returns an ImmutableSegment containing the result of applying the AffineTransform to segment.

Performance-sensitive code should use the applyTransform overload that takes a pre-allocated MutableSegment, so that instance can be reused across multiple calls.

public final @NonNull ImmutableTriangle applyTransform(@NonNull Triangle triangle)

Returns an ImmutableTriangle containing the result of applying the AffineTransform to triangle.

Performance-sensitive code should use the applyTransform overload that takes a pre-allocated MutableTriangle, so that instance can be reused across multiple calls.

public final @NonNull MutableParallelogram applyTransform(
    @NonNull Box box,
    @NonNull MutableParallelogram outParallelogram
)

Apply the AffineTransform to the Box and store the result in the MutableParallelogram. This is the only Apply function where the input cannot also be the output, as applying an Affine Transform to a Box makes a Parallelogram.

public final @NonNull MutableParallelogram applyTransform(
    @NonNull Parallelogram parallelogram,
    @NonNull MutableParallelogram outParallelogram
)

Apply the AffineTransform to the Parallelogram and store the result in the MutableParallelogram. The same MutableParallelogram can be used as both the input and output to avoid additional allocations.

public final @NonNull MutableVec applyTransform(@NonNull Vec point, @NonNull MutableVec outVec)

Apply the AffineTransform to the Vec and store the result in the MutableVec. The same MutableVec can be used as both the input and output to avoid additional allocations. Returns outVec.

Note that this treats point as a location, not an offset. If you want to transform an offset, you must also transform the origin and subtract that from the result, e.g.:

Vec.subtract(
  transform.applyTransform(vec, scratchPoint1),
  transform.applyTransform(Vec.ORIGIN, scratchPoint2),
  result
)

public final @NonNull MutableSegment applyTransform(
    @NonNull Segment segment,
    @NonNull MutableSegment outSegment
)

Apply the AffineTransform to the Segment and store the result in the MutableSegment. The same MutableSegment can be used as both the input and output to avoid additional allocations. Returns outSegment.

public final @NonNull MutableTriangle applyTransform(
    @NonNull Triangle triangle,
    @NonNull MutableTriangle outTriangle
)

Apply the AffineTransform to the Triangle and store the result in the MutableTriangle. The same MutableTriangle can be used as both the input and output to avoid additional allocations. Returns outTriangle.

public final @NonNull ImmutableAffineTransform computeInverse()

Returns the inverse of the AffineTransform.

Performance-sensitive code should use the computeInverse overload that takes a pre-allocated MutableAffineTransform, so that instance can be reused across multiple calls.

public final @NonNull MutableAffineTransform computeInverse(@NonNull MutableAffineTransform outAffineTransform)

Populates outAffineTransform with the inverse of this AffineTransform. The same MutableAffineTransform instance can be used as the output to avoid additional allocations. Returns outAffineTransform.

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

In performance-sensitive code, prefer to pass in an array that has already been allocated and is being reused, rather than relying on the default behavior of allocating a new instance for each call.

Prefer to apply this transform to an object, such as with applyTransform, rather than accessing the actual numeric values of this transform. This function is useful for when the values are needed in bulk but not to apply a transform, for example for serialization.

To set these values on a transform in the same order that they are retrieved here, use the ImmutableAffineTransform constructor or use MutableAffineTransform.setValues.

public 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 static final void multiply(
    @NonNull AffineTransform lhs,
    @NonNull AffineTransform rhs,
    @NonNull MutableAffineTransform output
)

Multiplies the lhs transform by the rhs transform as matrices, and stores the result in output. Note that, when performing matrix multiplication, the lhs transform is applied after the rhs transform; i.e., after calling this method, output contains a transform equivalent to applying rhs, then lhs.

public final void AndroidGraphicsConverter.populateMatrix(
    @NonNull AffineTransform receiver,
    @NonNull Matrix out
)

Writes the values from this AffineTransform to out.

Returns the modified Matrix to allow chaining calls.

public final @NonNull Matrix AndroidGraphicsConverter.toMatrix(@NonNull AffineTransform receiver)

Constructs a Matrix with the values from the AffineTransform.

Performance-sensitive code should use the populateMatrix overload that takes a pre-allocated Matrix, so that the instance can be reused across multiple calls.