ImmutableAffineTransform
class ImmutableAffineTransform : AffineTransform
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 MutableAffineTransform for mutable alternative to this class.
Summary
Public companion functions |
|
|---|---|
ImmutableAffineTransform |
Returns a transformation that scales in both the x- and y-direction by the given |
ImmutableAffineTransform |
Returns a transformation that scales in both the x- and y-direction by the given pair of factors; |
ImmutableAffineTransform |
Returns a transformation that scales in the x-direction by the given factor, centered about the origin. |
ImmutableAffineTransform |
Returns a transformation that scales in the y-direction by the given factor, centered about the origin. |
ImmutableAffineTransform |
Returns a transformation that translates by the given |
Public constructors |
|---|
ImmutableAffineTransform(values: @Size(min = 6) FloatArray)Like the primary constructor, but accepts a |
|
Constructs this transform with 6 float values, starting with the top left corner of the matrix and proceeding in row-major order. |
Public functions |
|
|---|---|
open operator Boolean |
Component-wise equality operator for |
open Int |
hashCode() |
open String |
toString() |
Inherited functions |
||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
Public companion functions
scale
fun scale(scaleFactor: Float): ImmutableAffineTransform
Returns a transformation that scales in both the x- and y-direction by the given scaleFactor, centered about the origin.
scale
fun scale(xScaleFactor: Float, yScaleFactor: Float): ImmutableAffineTransform
Returns 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.
scaleX
fun scaleX(scaleFactor: Float): ImmutableAffineTransform
Returns a transformation that scales in the x-direction by the given factor, centered about the origin.
scaleY
fun scaleY(scaleFactor: Float): ImmutableAffineTransform
Returns a transformation that scales in the y-direction by the given factor, centered about the origin.
translate
fun translate(offset: Vec): ImmutableAffineTransform
Returns a transformation that translates by the given offset vector.
Public constructors
ImmutableAffineTransform
ImmutableAffineTransform(values: @Size(min = 6) FloatArray)
Like the primary constructor, but accepts a FloatArray instead of individual Float values.
ImmutableAffineTransform
ImmutableAffineTransform(
m00: Float,
m10: Float,
m20: Float,
m01: Float,
m11: Float,
m21: Float
)
Constructs this transform with 6 float values, starting with the top left corner of the matrix and proceeding in row-major order. Prefer to create this object with functions that apply specific transform operations, such as scale or translate, rather than directly passing in the actual numeric values of this transform. This constructor is useful for when the values are needed to be provided all at once, for example for serialization. To access these values in the same order as they are passed in here, use AffineTransform.getValues. To construct this object using an array as input, there is another public constructor for that.
Public functions
equals
open operator fun equals(other: Any?): Boolean
Component-wise equality operator for ImmutableAffineTransform.
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.