MPERSP_0

static val MPERSP_0: Int

Value: 6

MPERSP_1

static val MPERSP_1: Int

Value: 7

MPERSP_2

static val MPERSP_2: Int

Value: 8

MSCALE_X

static val MSCALE_X: Int

Value: 0

MSCALE_Y

static val MSCALE_Y: Int

Value: 4

MSKEW_X

static val MSKEW_X: Int

Value: 1

MSKEW_Y

static val MSKEW_Y: Int

Value: 3

MTRANS_X

static val MTRANS_X: Int

Value: 2

MTRANS_Y

static val MTRANS_Y: Int

Value: 5

Matrix

Matrix()

Create an identity matrix

Matrix

Matrix(src: Matrix!)

Create a matrix that is a (deep) copy of src

dump

fun dump(pw: PrintWriter): Unit

Dumps a human-readable shortened string of the matrix into the given stream

equals

open fun equals(other: Any?): Boolean

Returns true iff obj is a Matrix and its values equal our values.

getValues

open fun getValues(values: FloatArray!): Unit

Copy 9 values from the matrix into the array.

hashCode

open fun hashCode(): Int

invert

open fun invert(inverse: Matrix!): Boolean

If this matrix can be inverted, return true and if inverse is not null, set inverse to be the inverse of this matrix. If this matrix cannot be inverted, ignore inverse and return false.

isAffine

open fun isAffine(): Boolean

Gets whether this matrix is affine. An affine matrix preserves straight lines and has no perspective.

isIdentity

open fun isIdentity(): Boolean

Returns true if the matrix is identity. This maybe faster than testing if (getType() == 0)

mapPoints

open fun mapPoints(pts: FloatArray!): Unit

Apply this matrix to the array of 2D points, and write the transformed points back into the array

mapPoints

open fun mapPoints(
    dst: FloatArray!, 
    src: FloatArray!
): Unit

Apply this matrix to the array of 2D points specified by src, and write the transformed points into the array of points specified by dst. The two arrays represent their "points" as pairs of floats [x, y].

mapPoints

open fun mapPoints(
    dst: FloatArray!, 
    dstIndex: Int, 
    src: FloatArray!, 
    srcIndex: Int, 
    pointCount: Int
): Unit

Apply this matrix to the array of 2D points specified by src, and write the transformed points into the array of points specified by dst. The two arrays represent their "points" as pairs of floats [x, y].

mapRadius

open fun mapRadius(radius: Float): Float

Return the mean radius of a circle after it has been mapped by this matrix. NOTE: in perspective this value assumes the circle has its center at the origen.

mapRect

open fun mapRect(rect: RectF!): Boolean

Apply this matrix to the rectangle, and write the transformed rectangle back into it. This is accomplished by transforming the 4 corners of rect, and then setting it to the bounds of those points

mapRect

open fun mapRect(
    dst: RectF!, 
    src: RectF!
): Boolean

Apply this matrix to the src rectangle, and write the transformed rectangle into dst. This is accomplished by transforming the 4 corners of src, and then setting dst to the bounds of those points.

mapVectors

open fun mapVectors(vecs: FloatArray!): Unit

Apply this matrix to the array of 2D vectors, and write the transformed vectors back into the array. Note: this method does not apply the translation associated with the matrix. Use Matrix.mapPoints(float[]) if you want the translation to be applied.

mapVectors

open fun mapVectors(
    dst: FloatArray!, 
    src: FloatArray!
): Unit

Apply this matrix to the array of 2D vectors specified by src, and write the transformed vectors into the array of vectors specified by dst. The two arrays represent their "vectors" as pairs of floats [x, y]. Note: this method does not apply the translation associated with the matrix. Use Matrix.mapPoints(float[], float[]) if you want the translation to be applied.

mapVectors

open fun mapVectors(
    dst: FloatArray!, 
    dstIndex: Int, 
    src: FloatArray!, 
    srcIndex: Int, 
    vectorCount: Int
): Unit

Apply this matrix to the array of 2D vectors specified by src, and write the transformed vectors into the array of vectors specified by dst. The two arrays represent their "vectors" as pairs of floats [x, y]. Note: this method does not apply the translation associated with the matrix. Use Matrix.mapPoints(float[], int, float[], int, int) if you want the translation to be applied.

postConcat

open fun postConcat(other: Matrix!): Boolean

Postconcats the matrix with the specified matrix. M' = other * M

postRotate

open fun postRotate(degrees: Float): Boolean

Postconcats the matrix with the specified rotation. M' = R(degrees) * M

postRotate

open fun postRotate(
    degrees: Float, 
    px: Float, 
    py: Float
): Boolean

Postconcats the matrix with the specified rotation. M' = R(degrees, px, py) * M

postScale

open fun postScale(
    sx: Float, 
    sy: Float
): Boolean

Postconcats the matrix with the specified scale. M' = S(sx, sy) * M

postScale

open fun postScale(
    sx: Float, 
    sy: Float, 
    px: Float, 
    py: Float
): Boolean

Postconcats the matrix with the specified scale. M' = S(sx, sy, px, py) * M

postSkew

open fun postSkew(
    kx: Float, 
    ky: Float
): Boolean

Postconcats the matrix with the specified skew. M' = K(kx, ky) * M

postSkew

open fun postSkew(
    kx: Float, 
    ky: Float, 
    px: Float, 
    py: Float
): Boolean

Postconcats the matrix with the specified skew. M' = K(kx, ky, px, py) * M

postTranslate

open fun postTranslate(
    dx: Float, 
    dy: Float
): Boolean

Postconcats the matrix with the specified translation. M' = T(dx, dy) * M

preConcat

open fun preConcat(other: Matrix!): Boolean

Preconcats the matrix with the specified matrix. M' = M * other

preRotate

open fun preRotate(degrees: Float): Boolean

Preconcats the matrix with the specified rotation. M' = M * R(degrees)

preRotate

open fun preRotate(
    degrees: Float, 
    px: Float, 
    py: Float
): Boolean

Preconcats the matrix with the specified rotation. M' = M * R(degrees, px, py)

preScale

open fun preScale(
    sx: Float, 
    sy: Float
): Boolean

Preconcats the matrix with the specified scale. M' = M * S(sx, sy)

preScale

open fun preScale(
    sx: Float, 
    sy: Float, 
    px: Float, 
    py: Float
): Boolean

Preconcats the matrix with the specified scale. M' = M * S(sx, sy, px, py)

preSkew

open fun preSkew(
    kx: Float, 
    ky: Float
): Boolean

Preconcats the matrix with the specified skew. M' = M * K(kx, ky)

preSkew

open fun preSkew(
    kx: Float, 
    ky: Float, 
    px: Float, 
    py: Float
): Boolean

Preconcats the matrix with the specified skew. M' = M * K(kx, ky, px, py)

preTranslate

open fun preTranslate(
    dx: Float, 
    dy: Float
): Boolean

Preconcats the matrix with the specified translation. M' = M * T(dx, dy)

rectStaysRect

open fun rectStaysRect(): Boolean

Returns true if will map a rectangle to another rectangle. This can be true if the matrix is identity, scale-only, or rotates a multiple of 90 degrees.

reset

open fun reset(): Unit

Set the matrix to identity

set

open fun set(src: Matrix!): Unit

(deep) copy the src matrix into this matrix. If src is null, reset this matrix to the identity matrix.

setConcat

open fun setConcat(
    a: Matrix!, 
    b: Matrix!
): Boolean

Set the matrix to the concatenation of the two specified matrices and return true.

Either of the two matrices may also be the target matrix, that is matrixA.setConcat(matrixA, matrixB); is valid.

In android.os.Build.VERSION_CODES#GINGERBREAD_MR1 and below, this function returns true only if the result can be represented. In android.os.Build.VERSION_CODES#HONEYCOMB and above, it always returns true.

setPolyToPoly

open fun setPolyToPoly(
    src: FloatArray!, 
    srcIndex: Int, 
    dst: FloatArray!, 
    dstIndex: Int, 
    pointCount: Int
): Boolean

Set the matrix such that the specified src points would map to the specified dst points. The "points" are represented as an array of floats, order [x0, y0, x1, y1, ...], where each "point" is 2 float values.

setRectToRect

open fun setRectToRect(
    src: RectF!, 
    dst: RectF!, 
    stf: Matrix.ScaleToFit!
): Boolean

Set the matrix to the scale and translate values that map the source rectangle to the destination rectangle, returning true if the result can be represented.

setRotate

open fun setRotate(degrees: Float): Unit

Set the matrix to rotate about (0,0) by the specified number of degrees.

setRotate

open fun setRotate(
    degrees: Float, 
    px: Float, 
    py: Float
): Unit

Set the matrix to rotate by the specified number of degrees, with a pivot point at (px, py). The pivot point is the coordinate that should remain unchanged by the specified transformation.

setScale

open fun setScale(
    sx: Float, 
    sy: Float
): Unit

Set the matrix to scale by sx and sy.

setScale

open fun setScale(
    sx: Float, 
    sy: Float, 
    px: Float, 
    py: Float
): Unit

Set the matrix to scale by sx and sy, with a pivot point at (px, py). The pivot point is the coordinate that should remain unchanged by the specified transformation.

setSinCos

open fun setSinCos(
    sinValue: Float, 
    cosValue: Float
): Unit

Set the matrix to rotate by the specified sine and cosine values.

setSinCos

open fun setSinCos(
    sinValue: Float, 
    cosValue: Float, 
    px: Float, 
    py: Float
): Unit

Set the matrix to rotate by the specified sine and cosine values, with a pivot point at (px, py). The pivot point is the coordinate that should remain unchanged by the specified transformation.

setSkew

open fun setSkew(
    kx: Float, 
    ky: Float
): Unit

Set the matrix to skew by sx and sy.

setSkew

open fun setSkew(
    kx: Float, 
    ky: Float, 
    px: Float, 
    py: Float
): Unit

Set the matrix to skew by sx and sy, with a pivot point at (px, py). The pivot point is the coordinate that should remain unchanged by the specified transformation.

setTranslate

open fun setTranslate(
    dx: Float, 
    dy: Float
): Unit

Set the matrix to translate by (dx, dy).

setValues

open fun setValues(values: FloatArray!): Unit

Copy 9 values from the array into the matrix. Depending on the implementation of Matrix, these may be transformed into 16.16 integers in the Matrix, such that a subsequent call to getValues() will not yield exactly the same values.

toShortString

open fun toShortString(): String!

toString

open fun toString(): String

IDENTITY_MATRIX

static val IDENTITY_MATRIX: Matrix

The identity matrix. Multiplying by another matrix M returns M. This matrix is immutable, and attempting to modify it will throw an IllegalStateException.