docs/SkMatrix_Reference.bmh

#Topic Matrix
#Alias Matrices ##
#Alias Matrix_Reference ##

#Class SkMatrix

#Code
#Populate
##

Matrix holds a 3 by 3 matrix for transforming coordinates. This allows mapping
Points and Vectors with translation, scaling, skewing, rotation, and
perspective.

Matrix elements are in row major order. Matrix does not have a constructor,
so it must be explicitly initialized. setIdentity initializes Matrix
so it has no effect. setTranslate, setScale, setSkew, setRotate, set9 and setAll
initializes all Matrix elements with the corresponding mapping.

Matrix includes a hidden variable that classifies the type of matrix to
improve performance. Matrix is not thread safe unless getType is called first.

# ------------------------------------------------------------------------------

#Method static SkMatrix MakeScale(SkScalar sx, SkScalar sy)
#In Constructors
#Line # constructs from scale on x-axis and y-axis ##
#Populate

#Example
#Image 4
canvas->concat(SkMatrix::MakeScale(4, 3));
canvas->drawBitmap(source, 0, 0);
##

#SeeAlso setScale postScale preScale

##

# ------------------------------------------------------------------------------

#Method static SkMatrix MakeScale(SkScalar scale)
#Populate

#Example
#Image 4
canvas->concat(SkMatrix::MakeScale(4));
canvas->drawBitmap(source, 0, 0);
##

#SeeAlso setScale postScale preScale

##

# ------------------------------------------------------------------------------

#Method static SkMatrix MakeTrans(SkScalar dx, SkScalar dy)
#In Constructors
#Line # constructs from translate on x-axis and y-axis ##
#Populate

#Example
#Image 4
SkMatrix matrix = SkMatrix::MakeTrans(64, 48);
for (int i = 0; i < 4; ++i) {
    canvas->drawBitmap(source, 0, 0);
    canvas->concat(matrix);
}
##

#SeeAlso setTranslate postTranslate preTranslate

##

# ------------------------------------------------------------------------------

#Method static SkMatrix MakeAll(SkScalar scaleX, SkScalar skewX,  SkScalar transX,
                                                      SkScalar skewY,  SkScalar scaleY, SkScalar transY,
                                                      SkScalar pers0, SkScalar pers1, SkScalar pers2)
#In Constructors
#Line # constructs all nine values ##
#Populate

#Example
    SkPaint p;
    SkFont font(nullptr, 64);
    for (SkScalar sx : { -1, 1 } ) {
        for (SkScalar sy : { -1, 1 } ) {
            SkAutoCanvasRestore autoRestore(canvas, true);
            SkMatrix m = SkMatrix::MakeAll(sx, 1, 128,    0, sy, 128,   0, 0, 1);
            canvas->concat(m);
            canvas->drawString("K", 0, 0, font, p);
        }
    }
##

#SeeAlso setAll set9 postConcat preConcat

##


# ------------------------------------------------------------------------------

#Enum TypeMask
#Line # bit field for Matrix complexity ##
#Code
#Populate
##

Enumeration of bit fields for mask returned by getType.
Used to identify the complexity of Matrix, to optimize performance.

#Const kIdentity_Mask 0
#Line # identity Matrix; all bits clear ##
all bits clear if Matrix is identity
##
#Const kTranslate_Mask 1
#Line # translation Matrix ##
set if Matrix has translation
##
#Const kScale_Mask 2
#Line # scale Matrix ##
set if Matrix scales x-axis or y-axis
##
#Const kAffine_Mask 4
#Line # skew or rotate Matrix ##
set if Matrix skews or rotates
##
#Const kPerspective_Mask 8
#Line # perspective Matrix ##
set if Matrix has perspective
##

#Example
    auto debugster = [](const char* prefix, const SkMatrix& matrix) -> void {
        SkString typeMask;
        typeMask += SkMatrix::kIdentity_Mask == matrix.getType() ? "kIdentity_Mask " : "";
        typeMask += SkMatrix::kTranslate_Mask & matrix.getType() ? "kTranslate_Mask " : "";
        typeMask += SkMatrix::kScale_Mask & matrix.getType() ? "kScale_Mask " : "";
        typeMask += SkMatrix::kAffine_Mask & matrix.getType() ? "kAffine_Mask " : "";
        typeMask += SkMatrix::kPerspective_Mask & matrix.getType() ? "kPerspective_Mask" : "";
        SkDebugf("after %s: %s\n", prefix, typeMask.c_str());
    };
SkMatrix matrix;
matrix.reset();
debugster("reset", matrix);
matrix.postTranslate(1, 0);
debugster("postTranslate", matrix);
matrix.postScale(2, 1);
debugster("postScale", matrix);
matrix.postRotate(45);
debugster("postScale", matrix);
SkPoint polys[][4] = {{{0, 0}, {0, 1}, {1, 1}, {1, 0}}, {{0, 0}, {0, 1}, {2, 1}, {1, 0}}};
matrix.setPolyToPoly(polys[0], polys[1], 4);
debugster("setPolyToPoly", matrix);
#StdOut
after reset: kIdentity_Mask
after postTranslate: kTranslate_Mask
after postScale: kTranslate_Mask kScale_Mask
after postScale: kTranslate_Mask kScale_Mask kAffine_Mask
after setPolyToPoly: kTranslate_Mask kScale_Mask kAffine_Mask kPerspective_Mask
##
##

#SeeAlso getType

##

# ------------------------------------------------------------------------------
#Subtopic Property
#Line # values and attributes ##
##

#Method TypeMask getType() const
#In Property
#Line # returns transform complexity ##
#Populate

#Example
SkMatrix matrix;
matrix.setAll(1, 0, 0,   0, 1, 0,    0, 0, 1);
SkDebugf("identity flags hex: %0x decimal: %d\n", matrix.getType(), matrix.getType());
matrix.setAll(1, 0, 0,   0, 1, 0,    0, 0, .5f);
SkDebugf("set all  flags hex: %0x decimal: %d\n", matrix.getType(), matrix.getType());
#StdOut
identity flags hex: 0 decimal: 0
set all  flags hex: f decimal: 15
##
##

#SeeAlso TypeMask

##

# ------------------------------------------------------------------------------

#Method bool isIdentity() const
#In Property
#Line # returns if matrix equals the identity Matrix  ##
#Populate

#Example
SkMatrix matrix;
matrix.setAll(1, 0, 0,   0, 1, 0,    0, 0, 1);
SkDebugf("is identity: %s\n", matrix.isIdentity() ? "true" : "false");
matrix.setAll(1, 0, 0,   0, 1, 0,    0, 0, 2);
SkDebugf("is identity: %s\n", matrix.isIdentity() ? "true" : "false");
#StdOut
is identity: true
is identity: false
##
##

#SeeAlso reset() setIdentity getType

##

# ------------------------------------------------------------------------------

#Method bool isScaleTranslate() const
#In Property
#Line # returns if transform is limited to scale and translate ##
#Populate

#Example
SkMatrix matrix;
for (SkScalar scaleX : { 1, 2 } ) {
    for (SkScalar translateX : { 0, 20 } ) {
        matrix.setAll(scaleX, 0, translateX,   0, 1, 0,    0, 0, 1);
        SkDebugf("is scale-translate: %s\n", matrix.isScaleTranslate() ? "true" : "false");
    }
}
#StdOut
is scale-translate: true
is scale-translate: true
is scale-translate: true
is scale-translate: true
##
##

#SeeAlso setScale isTranslate setTranslate getType

##

# ------------------------------------------------------------------------------

#Method bool isTranslate() const
#In Property
#Line # returns if transform is limited to translate ##
#Populate

#Example
SkMatrix matrix;
for (SkScalar scaleX : { 1, 2 } ) {
    for (SkScalar translateX : { 0, 20 } ) {
        matrix.setAll(scaleX, 0, translateX,   0, 1, 0,    0, 0, 1);
        SkDebugf("is translate: %s\n", matrix.isTranslate() ? "true" : "false");
    }
}
#StdOut
is translate: true
is translate: true
is translate: false
is translate: false
##
##

#SeeAlso setTranslate getType

##

# ------------------------------------------------------------------------------

#Method bool rectStaysRect() const
#In Property
#Line # returns if mapped Rect can be represented by another Rect ##
#Populate

#Example
SkMatrix matrix;
for (SkScalar angle: { 0, 90, 180, 270 } ) {
    matrix.setRotate(angle);
    SkDebugf("rectStaysRect: %s\n", matrix.rectStaysRect() ? "true" : "false");
}
#StdOut
rectStaysRect: true
rectStaysRect: true
rectStaysRect: true
rectStaysRect: true
##
##

#SeeAlso preservesAxisAlignment preservesRightAngles

##

# ------------------------------------------------------------------------------

#Method bool preservesAxisAlignment() const
#In Property
#Line # returns if mapping restricts to 90 degree multiples and mirroring ##
#Populate

#Example
SkMatrix matrix;
for (SkScalar angle: { 0, 90, 180, 270 } ) {
    matrix.setRotate(angle);
    SkDebugf("preservesAxisAlignment: %s\n", matrix.preservesAxisAlignment() ? "true" : "false");
}
#StdOut
preservesAxisAlignment: true
preservesAxisAlignment: true
preservesAxisAlignment: true
preservesAxisAlignment: true
##
##

#SeeAlso rectStaysRect preservesRightAngles

##

# ------------------------------------------------------------------------------

#Method bool hasPerspective() const
#In Property
#Line # returns if transform includes perspective ##
#Populate

#Example
#Image 4
SkMatrix matrix;
SkPoint bitmapBounds[4], perspect[4] = {{50, 10}, {180, 40}, {236, 176}, {10, 206}};
SkRect::Make(source.bounds()).toQuad(bitmapBounds);
matrix.setPolyToPoly(bitmapBounds, perspect, 4);
canvas->concat(matrix);
SkString string;
string.printf("hasPerspective %s", matrix.hasPerspective() ? "true" : "false");
canvas->drawBitmap(source, 0, 0);
SkPaint paint;
SkFont font(nullptr, 48);
canvas->drawString(string, 0, source.bounds().height() + 48, font, paint);
##

#SeeAlso setAll set9 MakeAll

##

# ------------------------------------------------------------------------------

#Method bool isSimilarity(SkScalar tol = SK_ScalarNearlyZero) const
#In Property
#Line # returns if transform is limited to square scale and rotation ##
#Populate

#Example
#Description
String is drawn four times through but only two are visible. Drawing the pair
with isSimilarity false reveals the pair not visible through the matrix.
##
    SkPaint p;
    p.setAntiAlias(true);
    SkMatrix m;
    int below = 175;
    for (SkScalar sx : { -1, 1 } ) {
        for (SkScalar sy : { -1, 1 } ) {
            m.setAll(sx, 1, 128,    1, sy, 32,   0, 0, 1);
            bool isSimilarity = m.isSimilarity();
            SkString str;
            str.printf("sx: %g sy: %g sim: %s", sx, sy, isSimilarity ? "true" : "false");
            {
                SkAutoCanvasRestore autoRestore(canvas, true);
                canvas->concat(m);
                canvas->drawString(str, 0, 0, p);
            }
            if (!isSimilarity) {
                canvas->drawString(str, 40, below, p);
                below += 20;
            }
        }
    }
##

#SeeAlso isScaleTranslate preservesRightAngles rectStaysRect isFixedStepInX

##

# ------------------------------------------------------------------------------

#Method bool preservesRightAngles(SkScalar tol = SK_ScalarNearlyZero) const
#In Property
#Line # returns if mapped 90 angle remains 90 degrees ##
#Populate

#Example
#Height 128
#Description
Equal scale is both similar and preserves right angles.
Unequal scale is not similar but preserves right angles.
Skews are not similar and do not preserve right angles.
##
SkPaint p;
p.setAntiAlias(true);
SkMatrix m;
int pos = 0;
for (SkScalar sx : { 1, 2 } ) {
    for (SkScalar kx : { 0, 1 } ) {
        m.setAll(sx, kx, 16,    0, 1, 32,   0, 0, 1);
        bool isSimilarity = m.isSimilarity();
        bool preservesRightAngles = m.preservesRightAngles();
        SkString str;
        str.printf("sx: %g kx: %g %s %s", sx, kx, isSimilarity ? "sim" : "",
                    preservesRightAngles ? "right" : "");
        SkAutoCanvasRestore autoRestore(canvas, true);
        canvas->concat(m);
        canvas->drawString(str, 0, pos, p);
        pos += 20;
    }
}
##

#SeeAlso isScaleTranslate isSimilarity rectStaysRect isFixedStepInX

##

# ------------------------------------------------------------------------------

#Subtopic MemberIndex
#In Constant
#Line # member indices ##
#Filter kM
#Code
#Populate
##

Matrix organizes its values in row order. These members correspond to
each value in Matrix.

#Const kMScaleX 0
#Line # horizontal scale factor ##
##
#Const kMSkewX 1
#Line # horizontal skew factor ##
##
#Const kMTransX 2
#Line # horizontal translation ##
##
#Const kMSkewY 3
#Line # vertical skew factor ##
##
#Const kMScaleY 4
#Line # vertical scale factor ##
##
#Const kMTransY 5
#Line # vertical translation ##
##
#Const kMPersp0 6
#Line # input x perspective factor ##
##
#Const kMPersp1 7
#Line # input y perspective factor ##
##
#Const kMPersp2 8
#Line # perspective bias ##
##

#Example
SkPaint black;
SkFont font(nullptr, 48);
SkPaint gray = black;
gray.setColor(0xFF9f9f9f);
SkScalar offset[] = { 1.5f, 1.5f, 20,   1.5f, 1.5f, 20,   .03f, .01f, 2 };
for (int i : { SkMatrix::kMScaleX, SkMatrix::kMSkewX,  SkMatrix::kMTransX,
               SkMatrix::kMSkewY,  SkMatrix::kMScaleY, SkMatrix::kMTransY,
               SkMatrix::kMPersp0, SkMatrix::kMPersp1, SkMatrix::kMPersp2 } ) {
    SkMatrix m;
    m.setIdentity();
    m.set(i, offset[i]);
    SkAutoCanvasRestore autoRestore(canvas, true);
    canvas->translate(22 + (i % 3) * 88, 44 + (i / 3) * 88);
    canvas->drawString("&", 0, 0, font, gray);
    canvas->concat(m);
    canvas->drawString("&", 0, 0, font, black);
}
##

#SeeAlso get() set()

##

# ------------------------------------------------------------------------------

#Subtopic AffineIndex
#In Constant
#Line # affine member indices ##
#Filter KA

#Code
#Populate
##

Affine arrays are in column major order to match the matrix used by
PDF and XPS.

#Const kAScaleX 0
#Line # horizontal scale factor ##
##
#Const kASkewY 1
#Line # vertical skew factor ##
##
#Const kASkewX 2
#Line # horizontal skew factor ##
##
#Const kAScaleY 3
#Line # vertical scale factor ##
##
#Const kATransX 4
#Line # horizontal translation ##
##
#Const kATransY 5
#Line # vertical translation ##
##

#NoExample
##

#SeeAlso SetAffineIdentity asAffine setAffine

##

# ------------------------------------------------------------------------------

#Method SkScalar operator[](int index) const

#Line # returns Matrix value ##
#Populate

#Example
SkMatrix matrix;
matrix.setScale(42, 24);
SkDebugf("matrix[SkMatrix::kMScaleX] %c= 42\n", matrix[SkMatrix::kMScaleX] == 42 ? '=' : '!');
SkDebugf("matrix[SkMatrix::kMScaleY] %c= 24\n", matrix[SkMatrix::kMScaleY] == 24 ? '=' : '!');
#StdOut
matrix[SkMatrix::kMScaleX] == 42
matrix[SkMatrix::kMScaleY] == 24
##
##

#SeeAlso get set

##

# ------------------------------------------------------------------------------

#Method SkScalar get(int index) const
#In Property
#Line # returns one of nine Matrix values ##
#Populate

#Example
SkMatrix matrix;
matrix.setSkew(42, 24);
SkDebugf("matrix.get(SkMatrix::kMSkewX) %c= 42\n",
         matrix.get(SkMatrix::kMSkewX) == 42 ? '=' : '!');
SkDebugf("matrix.get(SkMatrix::kMSkewY) %c= 24\n",
         matrix.get(SkMatrix::kMSkewY) == 24 ? '=' : '!');
#StdOut
matrix.get(SkMatrix::kMSkewX) == 42
matrix.get(SkMatrix::kMSkewY) == 24
##
##

#SeeAlso operator[](int index) set

##

# ------------------------------------------------------------------------------

#Method SkScalar getScaleX() const
#In Property
#Line # returns horizontal scale factor ##
#Populate

#Example
SkMatrix matrix;
matrix.setScale(42, 24);
SkDebugf("matrix.getScaleX() %c= 42\n", matrix.getScaleX() == 42 ? '=' : '!');
#StdOut
matrix.getScaleX() == 42
##
##

#SeeAlso get getScaleY setScaleX setScale

##

# ------------------------------------------------------------------------------

#Method SkScalar getScaleY() const
#In Property
#Line # returns vertical scale factor ##
#Populate

#Example
SkMatrix matrix;
matrix.setScale(42, 24);
SkDebugf("matrix.getScaleY() %c= 24\n", matrix.getScaleY() == 24 ? '=' : '!');
#StdOut
matrix.getScaleY() == 24
##
##

#SeeAlso get getScaleX setScaleY setScale

##

# ------------------------------------------------------------------------------

#Method SkScalar getSkewY() const
#In Property
#Line # returns vertical skew factor ##
#Populate

#Example
SkMatrix matrix;
matrix.setSkew(42, 24);
SkDebugf("matrix.getSkewY() %c= 24\n", matrix.getSkewY() == 24 ? '=' : '!');
#StdOut
matrix.getSkewY() == 24
##
##

#SeeAlso get getSkewX setSkewY setSkew

##

# ------------------------------------------------------------------------------

#Method SkScalar getSkewX() const
#In Property
#Line # returns horizontal skew factor ##
#Populate

#Example
SkMatrix matrix;
matrix.setSkew(42, 24);
SkDebugf("matrix.getSkewX() %c= 42\n", matrix.getSkewX() == 42 ? '=' : '!');
#StdOut
matrix.getSkewX() == 42
##
##

#SeeAlso get getSkewY setSkewX setSkew

##

# ------------------------------------------------------------------------------

#Method SkScalar getTranslateX() const
#In Property
#Line # returns horizontal translation ##
#Populate

#Example
SkMatrix matrix;
matrix.setTranslate(42, 24);
SkDebugf("matrix.getTranslateX() %c= 42\n", matrix.getTranslateX() == 42 ? '=' : '!');
#StdOut
matrix.getTranslateX() == 42
##
##

#SeeAlso get getTranslateY setTranslateX setTranslate

##

# ------------------------------------------------------------------------------

#Method SkScalar getTranslateY() const
#In Property
#Line # returns vertical translation ##
#Populate

#Example
SkMatrix matrix;
matrix.setTranslate(42, 24);
SkDebugf("matrix.getTranslateY() %c= 24\n", matrix.getTranslateY() == 24 ? '=' : '!');
#StdOut
matrix.getTranslateY() == 24
##
##

#SeeAlso get getTranslateX setTranslateY setTranslate

##

# ------------------------------------------------------------------------------

#Method SkScalar getPerspX() const
#In Property
#Line # returns input x perspective factor ##
#Populate

#Example
    SkMatrix m;
    m.setIdentity();
    m.set(SkMatrix::kMPersp0, -0.004f);
    SkAutoCanvasRestore autoRestore(canvas, true);
    canvas->translate(22, 144);
    SkPaint black;
    SkFont font(nullptr, 24);
    SkPaint gray = black;
    gray.setColor(0xFF9f9f9f);
    SkString string;
    string.appendScalar(m.getPerspX());
    canvas->drawString(string, 0, -72, font, gray);
    canvas->concat(m);
    canvas->drawString(string, 0, 0, font, black);
##

#SeeAlso kMPersp0 getPerspY

##

# ------------------------------------------------------------------------------

#Method SkScalar getPerspY() const
#In Property
#Line # returns input y perspective factor ##
#Populate

#Example
    SkMatrix m;
    m.setIdentity();
    m.set(SkMatrix::kMPersp1, -0.004f);
    SkAutoCanvasRestore autoRestore(canvas, true);
    canvas->translate(22, 144);
    SkPaint black;
    SkFont font(nullptr, 24);
    SkPaint gray;
    gray.setColor(0xFF9f9f9f);
    SkString string;
    string.appendScalar(m.getPerspY());
    canvas->drawString(string, 0, -72, font, gray);
    canvas->concat(m);
    canvas->drawString(string, 0, 0, font, black);
##

#SeeAlso kMPersp1 getPerspX

##

# ------------------------------------------------------------------------------

#Method SkScalar& operator[](int index)

#Line # returns writable reference to Matrix value ##
#Populate

#Example
SkMatrix matrix;
matrix.setIdentity();
SkDebugf("with identity matrix: x = %g\n", matrix.mapXY(24, 42).fX);
SkScalar& skewRef = matrix[SkMatrix::kMSkewX];
skewRef = 0;
SkDebugf("after skew x mod:     x = %g\n", matrix.mapXY(24, 42).fX);
skewRef = 1;
SkDebugf("after 2nd skew x mod: x = %g\n", matrix.mapXY(24, 42).fX);
matrix.dirtyMatrixTypeCache();
SkDebugf("after dirty cache:    x = %g\n", matrix.mapXY(24, 42).fX);
#StdOut
with identity matrix: x = 24
after skew x mod:     x = 24
after 2nd skew x mod: x = 24
after dirty cache:    x = 66
##
##

#SeeAlso get dirtyMatrixTypeCache set

##

# ------------------------------------------------------------------------------
#Subtopic Set
#Line # sets one or more matrix values ##
##

#Method void set(int index, SkScalar value)
#In Set
#Line # sets one value ##
#Populate

#Example
SkMatrix matrix;
matrix.setIdentity();
SkDebugf("with identity matrix: x = %g\n", matrix.mapXY(24, 42).fX);
matrix.set(SkMatrix::kMSkewX, 0);
SkDebugf("after skew x mod:     x = %g\n", matrix.mapXY(24, 42).fX);
matrix.set(SkMatrix::kMSkewX, 1);
SkDebugf("after 2nd skew x mod: x = %g\n", matrix.mapXY(24, 42).fX);
#StdOut
with identity matrix: x = 24
after skew x mod:     x = 24
after 2nd skew x mod: x = 66
##
##

#SeeAlso operator[] get

#Method ##

# ------------------------------------------------------------------------------

#Method void setScaleX(SkScalar v)
#In Set
#Line # sets horizontal scale factor ##
#Populate

#Example
#Height 64
SkPaint paint;
SkFont font(nullptr, 24);
canvas->drawString("normal", 12, 24, font, paint);
SkMatrix matrix;
matrix.setIdentity();
matrix.setScaleX(3);
canvas->concat(matrix);
canvas->drawString("x scale", 0, 48, font, paint);
##

#SeeAlso set setScale setScaleY

#Method ##

# ------------------------------------------------------------------------------

#Method void setScaleY(SkScalar v)
#In Set
#Line # sets vertical scale factor ##
#Populate

#Example
#Height 192
SkPaint paint;
SkFont font(nullptr, 24);
canvas->drawString("normal", 12, 24, font, paint);
SkMatrix matrix;
matrix.setIdentity();
matrix.setScaleY(3);
canvas->concat(matrix);
canvas->drawString("y scale", 12, 48, font, paint);
##

#SeeAlso set setScale setScaleX

#Method ##

# ------------------------------------------------------------------------------

#Method void setSkewY(SkScalar v)
#In Set
#Line # sets vertical skew factor ##
#Populate

#Example
#Height 96
SkPaint paint;
SkFont font(nullptr, 24);
canvas->drawString("normal", 12, 24, font, paint);
SkMatrix matrix;
matrix.setIdentity();
matrix.setSkewY(.3f);
canvas->concat(matrix);
canvas->drawString("y skew", 12, 48, font, paint);
##

#SeeAlso set setSkew setSkewX

#Method ##

# ------------------------------------------------------------------------------

#Method void setSkewX(SkScalar v)
#In Set
#Line # sets horizontal skew factor ##
#Populate

#Example
#Height 64
SkPaint paint;
SkFont font(nullptr, 24);
canvas->drawString("normal", 12, 24, font, paint);
SkMatrix matrix;
matrix.setIdentity();
matrix.setSkewX(-.7f);
canvas->concat(matrix);
canvas->drawString("x skew", 36, 48, font, paint);
##

#SeeAlso set setSkew setSkewX

#Method ##

# ------------------------------------------------------------------------------

#Method void setTranslateX(SkScalar v)
#In Set
#Line # sets horizontal translation ##
#Populate

#Example
#Height 48
SkPaint paint;
SkFont font(nullptr, 24);
canvas->drawString("normal", 8, 24, font, paint);
SkMatrix matrix;
matrix.setIdentity();
matrix.setTranslateX(96);
canvas->concat(matrix);
canvas->drawString("x translate", 8, 24, font, paint);
##

#SeeAlso set setTranslate setTranslateY

#Method ##

# ------------------------------------------------------------------------------

#Method void setTranslateY(SkScalar v)
#In Set
#Line # sets vertical translation ##
#Populate

#Example
#Height 64
SkPaint paint;
SkFont font(nullptr, 24);
canvas->drawString("normal", 8, 24, font, paint);
SkMatrix matrix;
matrix.setIdentity();
matrix.setTranslateY(24);
canvas->concat(matrix);
canvas->drawString("y translate", 8, 24, font, paint);
##

#SeeAlso set setTranslate setTranslateX

#Method ##

# ------------------------------------------------------------------------------

#Method void setPerspX(SkScalar v)
#In Set
#Line # sets input x perspective factor ##
#Populate

#Example
#Image 4
for (SkScalar perspX : { -.003f, 0.f, .003f, .012f } ) {
    SkMatrix matrix;
    matrix.setIdentity();
    matrix.setPerspX(perspX);
    canvas->save();
    canvas->concat(matrix);
    canvas->drawBitmap(source, 0, 0);
    canvas->restore();
    canvas->translate(64, 64);
}
##

#SeeAlso getPerspX set setAll set9 MakeAll

#Method ##

# ------------------------------------------------------------------------------

#Method void setPerspY(SkScalar v)
#In Set
#Line # sets input y perspective factor ##
#Populate

#Example
#Image 4
for (SkScalar perspX : { -.003f, 0.f, .003f, .012f } ) {
    SkMatrix matrix;
    matrix.setIdentity();
    matrix.setPerspY(perspX);
    canvas->save();
    canvas->concat(matrix);
    canvas->drawBitmap(source, 0, 0);
    canvas->restore();
    canvas->translate(64, 64);
}
##

#SeeAlso getPerspY set setAll set9 MakeAll

#Method ##

# ------------------------------------------------------------------------------

#Method void setAll(SkScalar scaleX, SkScalar skewX,  SkScalar transX,
                SkScalar skewY,  SkScalar scaleY, SkScalar transY,
                SkScalar persp0, SkScalar persp1, SkScalar persp2)
#In Set
#Line # sets all values from parameters ##
#Populate

#Example
#Height 128
    SkPaint p;
    SkFont font(nullptr, 64);
    SkMatrix m;
    for (SkScalar sx : { -1, 1 } ) {
        for (SkScalar sy : { -1, 1 } ) {
            SkAutoCanvasRestore autoRestore(canvas, true);
            m.setAll(sx, 1, 128,    0, sy, 64,   0, 0, 1);
            canvas->concat(m);
            canvas->drawString("K", 0, 0, font, p);
        }
    }
##

#SeeAlso set9 MakeAll

#Method ##

# ------------------------------------------------------------------------------

#Method void get9(SkScalar buffer[9]) const
#In Property
#Line # returns all nine Matrix values ##
#Populate

#Example
SkMatrix matrix = SkMatrix::MakeRectToRect({0, 0, 1, 1}, {3, 4, 7, 9},
                                           SkMatrix::kFill_ScaleToFit);
SkScalar b[9];
matrix.get9(b);
SkDebugf("{%g, %g, %g},\n{%g, %g, %g},\n{%g, %g, %g}\n", b[0], b[1], b[2],
         b[3], b[4], b[5], b[6], b[7], b[8]);
#StdOut
{4, 0, 3},
{0, 5, 4},
{0, 0, 1}
##
##

#SeeAlso set9

#Method ##

# ------------------------------------------------------------------------------

#Method void set9(const SkScalar buffer[9])
#In Set
#In Constructors
#Line # sets all values from Scalar array ##
#Populate

#Example
#Image 4
SkMatrix m;
SkScalar buffer[9] = {4, 0, 3,    0, 5, 4,     0, 0, 1};
m.set9(buffer);
canvas->concat(m);
canvas->drawBitmap(source, 0, 0);
##

#SeeAlso setAll get9 MakeAll

#Method ##

# ------------------------------------------------------------------------------

#Method void reset()
#In Constructors
#In Set
#Line # sets Matrix to identity ##
#Populate

#Example
SkMatrix m;
m.reset();
SkDebugf("m.isIdentity(): %s\n", m.isIdentity() ? "true" : "false");
#StdOut
m.isIdentity(): true
##
##

#SeeAlso isIdentity setIdentity

#Method ##

# ------------------------------------------------------------------------------

#Method void setIdentity()
#In Constructors
#In Set
#Line # sets Matrix to identity ##
#Populate

#Example
SkMatrix m;
m.setIdentity();
SkDebugf("m.isIdentity(): %s\n", m.isIdentity() ? "true" : "false");
#StdOut
m.isIdentity(): true
##
##

#SeeAlso isIdentity reset

#Method ##

# ------------------------------------------------------------------------------

#Method void setTranslate(SkScalar dx, SkScalar dy)
#In Constructors
#In Set
#Line # sets to translate on x-axis and y-axis ##
#Populate

#Example
#Height 64
SkPaint paint;
SkFont font(nullptr, 24);
canvas->drawString("normal", 8, 24, font, paint);
SkMatrix matrix;
matrix.setTranslate(96, 24);
canvas->concat(matrix);
canvas->drawString("translate", 8, 24, font, paint);
##

#SeeAlso setTranslateX setTranslateY

#Method ##

# ------------------------------------------------------------------------------

#Method void setTranslate(const SkVector& v)
#Populate

#Example
#Height 64
SkPaint paint;
SkFont font(nullptr, 24);
canvas->drawString("normal", 8, 24, font, paint);
SkMatrix matrix;
matrix.setTranslate({96, 24});
canvas->concat(matrix);
canvas->drawString("translate", 8, 24, font, paint);
##

#SeeAlso setTranslateX setTranslateY MakeTrans

#Method ##

# ------------------------------------------------------------------------------

#Method void setScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py)
#In Constructors
#In Set
#Line # sets to scale about a point ##
#Populate

#Example
#Height 128
    SkPaint p;
    SkFont font(nullptr, 64);
    SkMatrix m;
    for (SkScalar sx : { -1, 1 } ) {
        for (SkScalar sy : { -1, 1 } ) {
            SkAutoCanvasRestore autoRestore(canvas, true);
            m.setScale(sx, sy, 128, 64);
            canvas->concat(m);
            canvas->drawString("%", 128, 64, font, p);
        }
    }
##

#SeeAlso setScaleX setScaleY MakeScale preScale postScale

#Method ##

# ------------------------------------------------------------------------------

#Method void setScale(SkScalar sx, SkScalar sy)
#Populate

#Example
#Height 128
    SkPaint p;
    SkFont font(nullptr, 64);
    SkMatrix m;
    for (SkScalar sx : { -1, 1 } ) {
        for (SkScalar sy : { -1, 1 } ) {
            SkAutoCanvasRestore autoRestore(canvas, true);
            m.setScale(sx, sy);
            m.postTranslate(128, 64);
            canvas->concat(m);
            canvas->drawString("@", 0, 0, font, p);
        }
    }
##

#SeeAlso setScaleX setScaleY MakeScale preScale postScale

#Method ##

# ------------------------------------------------------------------------------

#Method void setRotate(SkScalar degrees, SkScalar px, SkScalar py)
#In Constructors
#In Set
#Line # sets to rotate about a point ##
#Populate

#Example
#Height 128
    SkPaint paint;
    paint.setColor(SK_ColorGRAY);
    paint.setAntiAlias(true);
    SkRect rect = {20, 20, 100, 100};
    canvas->drawRect(rect, paint);
    paint.setColor(SK_ColorRED);
    SkMatrix matrix;
    matrix.setRotate(25, rect.centerX(), rect.centerY());
    canvas->concat(matrix);
    canvas->drawRect(rect, paint);
##

#SeeAlso setSinCos preRotate postRotate

#Method ##

# ------------------------------------------------------------------------------

#Method void setRotate(SkScalar degrees)
#Populate

#Example
#Height 128
    SkPaint paint;
    paint.setColor(SK_ColorGRAY);
    paint.setAntiAlias(true);
    SkRect rect = {20, 20, 100, 100};
    canvas->drawRect(rect, paint);
    paint.setColor(SK_ColorRED);
    SkMatrix matrix;
    matrix.setRotate(25);
    canvas->translate(rect.centerX(), rect.centerY());
    canvas->concat(matrix);
    canvas->translate(-rect.centerX(), -rect.centerY());
    canvas->drawRect(rect, paint);
##

#SeeAlso setSinCos preRotate postRotate

#Method ##

# ------------------------------------------------------------------------------

#Method void setSinCos(SkScalar sinValue, SkScalar cosValue,
                   SkScalar px, SkScalar py)
#In Constructors
#In Set
#Line # sets to rotate and scale about a point ##
#Populate

#Example
#Height 128
    SkPaint paint;
    paint.setColor(SK_ColorGRAY);
    paint.setAntiAlias(true);
    SkRect rect = {20, 20, 100, 100};
    canvas->drawRect(rect, paint);
    paint.setColor(SK_ColorRED);
    SkMatrix matrix;
    matrix.setSinCos(.25f, .85f, rect.centerX(), rect.centerY());
    canvas->concat(matrix);
    canvas->drawRect(rect, paint);
##

#SeeAlso setRotate setScale setRSXform

#Method ##

# ------------------------------------------------------------------------------

#Method void setSinCos(SkScalar sinValue, SkScalar cosValue)
#Populate

#Example
#Description
Canvas needs offset after applying Matrix to pivot about Rect center.
##
#Height 128
    SkPaint paint;
    paint.setColor(SK_ColorGRAY);
    paint.setAntiAlias(true);
    SkRect rect = {20, 20, 100, 100};
    canvas->drawRect(rect, paint);
    paint.setColor(SK_ColorRED);
    SkMatrix matrix;
    matrix.setSinCos(.25f, .85f);
    matrix.postTranslate(rect.centerX(), rect.centerY());
    canvas->concat(matrix);
    canvas->translate(-rect.centerX(), -rect.centerY());
    canvas->drawRect(rect, paint);
##

#SeeAlso setRotate setScale setRSXform

#Method ##

# ------------------------------------------------------------------------------

#Method SkMatrix& setRSXform(const SkRSXform& rsxForm)
#In Constructors
#In Set
#Line # sets to rotate, scale, and translate ##
#Populate

#Example
#Description
Canvas needs offset after applying Matrix to pivot about Rect center.
##
#Height 128
    SkPaint paint;
    paint.setColor(SK_ColorGRAY);
    paint.setAntiAlias(true);
    SkRect rect = {20, 20, 100, 100};
    canvas->drawRect(rect, paint);
    paint.setColor(SK_ColorRED);
    SkMatrix matrix;
    matrix.setRSXform(SkRSXform::Make(.85f, .25f, rect.centerX(), rect.centerY()));
    canvas->concat(matrix);
    canvas->translate(-rect.centerX(), -rect.centerY());
    canvas->drawRect(rect, paint);
##

#SeeAlso setSinCos setScale setTranslate

#Method ##

# ------------------------------------------------------------------------------

#Method void setSkew(SkScalar kx, SkScalar ky, SkScalar px, SkScalar py)
#In Constructors
#In Set
#Line # sets to skew about a point ##
#Populate

#Example
    SkPaint p;
    SkFont font(nullptr, 48);
    SkMatrix m;
    for (SkScalar sx : { -1, 0, 1 } ) {
        for (SkScalar sy : { -1, 0, 1 } ) {
            SkAutoCanvasRestore autoRestore(canvas, true);
            m.setSkew(sx, sy, 96 + 64 * sx, 128 + 48 * sy);
            canvas->concat(m);
            canvas->drawString("K", 96 + 64 * sx, 128 + 48 * sy, font, p);
        }
    }
##

#SeeAlso setSkewX setSkewY preSkew postSkew

#Method ##

# ------------------------------------------------------------------------------

#Method void setSkew(SkScalar kx, SkScalar ky)
#Populate

#Example
    SkPaint p;
    SkFont font(nullptr, 48);
    SkMatrix m;
    for (SkScalar sx : { -1, 0, 1 } ) {
        for (SkScalar sy : { -1, 0, 1 } ) {
            SkAutoCanvasRestore autoRestore(canvas, true);
            m.setSkew(sx, sy);
            m.postTranslate(96 + 64 * sx, 128 + 48 * sy);
            canvas->concat(m);
            canvas->drawString("K", 0, 0, font, p);
        }
    }
##

#SeeAlso setSkewX setSkewY preSkew postSkew

#Method ##

# ------------------------------------------------------------------------------

#Method void setConcat(const SkMatrix& a, const SkMatrix& b)
#In Constructors
#In Set
#Line # sets to Matrix parameter multiplied by Matrix parameter ##
#Populate

#Example
#Image 3
#Description
setPolyToPoly creates perspective matrices, one the inverse of the other.
Multiplying the matrix by its inverse turns into an identity matrix.
##
SkMatrix matrix, matrix2;
SkPoint bitmapBounds[4], perspect[4] = {{50, 10}, {180, 40}, {236, 176}, {10, 206}};
SkRect::Make(source.bounds()).toQuad(bitmapBounds);
matrix.setPolyToPoly(bitmapBounds, perspect, 4);
matrix2.setPolyToPoly(perspect, bitmapBounds, 4);
matrix.setConcat(matrix, matrix2);
canvas->concat(matrix);
canvas->drawBitmap(source, 0, 0);
##

#SeeAlso Concat preConcat postConcat SkCanvas::concat

#Method ##

# ------------------------------------------------------------------------------

#Method void preTranslate(SkScalar dx, SkScalar dy)
#In Set
#In Operators
#Line # pre-multiplies Matrix by translation ##
#Populate

#Example
#Height 160
    SkPaint paint;
    paint.setAntiAlias(true);
    SkRect rect = {20, 20, 100, 100};
    for (int i = 0; i < 2; ++i ) {
        SkMatrix matrix;
        i == 0 ? matrix.reset(): matrix.setRotate(25, rect.centerX(), 320);
        {
            SkAutoCanvasRestore acr(canvas, true);
            canvas->concat(matrix);
            paint.setColor(SK_ColorGRAY);
            canvas->drawRect(rect, paint);
        }
        paint.setColor(SK_ColorRED);
        for (int j = 0; j < 2; ++j ) {
            SkAutoCanvasRestore acr(canvas, true);
            matrix.preTranslate(40, 40);
            canvas->concat(matrix);
            canvas->drawCircle(0, 0, 3, paint);
        }
    }
##

#SeeAlso postTranslate setTranslate MakeTrans

#Method ##

# ------------------------------------------------------------------------------

#Method void preScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py)
#In Set
#In Operators
#Line # pre-multiplies Matrix by scale ##
#Populate

#Example
#Image 3
SkMatrix matrix;
SkPoint bitmapBounds[4], perspect[4] = {{50, 10}, {180, 40}, {236, 176}, {10, 206}};
SkRect::Make(source.bounds()).toQuad(bitmapBounds);
matrix.setPolyToPoly(bitmapBounds, perspect, 4);
matrix.preScale(.75f, 1.5f, source.width() / 2, source.height() / 2);
canvas->concat(matrix);
canvas->drawBitmap(source, 0, 0);
##

#SeeAlso postScale setScale MakeScale

#Method ##

# ------------------------------------------------------------------------------

#Method void preScale(SkScalar sx, SkScalar sy)
#In Set
#In Operators
#Populate

#Example
#Image 3
SkMatrix matrix;
SkPoint bitmapBounds[4], perspect[4] = {{50, 10}, {180, 40}, {236, 176}, {10, 206}};
SkRect::Make(source.bounds()).toQuad(bitmapBounds);
matrix.setPolyToPoly(bitmapBounds, perspect, 4);
matrix.preScale(.75f, 1.5f);
canvas->concat(matrix);
canvas->drawBitmap(source, 0, 0);
##

#SeeAlso postScale setScale MakeScale

#Method ##

# ------------------------------------------------------------------------------

#Method void preRotate(SkScalar degrees, SkScalar px, SkScalar py)
#In Set
#In Operators
#Line # pre-multiplies Matrix by rotation ##
#Populate

#Example
#Image 3
SkMatrix matrix;
SkPoint bitmapBounds[4], perspect[4] = {{50, 10}, {180, 40}, {236, 176}, {10, 206}};
SkRect::Make(source.bounds()).toQuad(bitmapBounds);
matrix.setPolyToPoly(bitmapBounds, perspect, 4);
matrix.preRotate(45, source.width() / 2, source.height() / 2);
canvas->concat(matrix);
canvas->drawBitmap(source, 0, 0);
##

#SeeAlso postRotate setRotate

#Method ##

# ------------------------------------------------------------------------------

#Method void preRotate(SkScalar degrees)
#Populate

#Example
#Image 3
SkMatrix matrix;
SkPoint bitmapBounds[4], perspect[4] = {{50, 10}, {180, 40}, {236, 176}, {10, 206}};
SkRect::Make(source.bounds()).toQuad(bitmapBounds);
matrix.setPolyToPoly(bitmapBounds, perspect, 4);
matrix.preRotate(45);
canvas->concat(matrix);
canvas->drawBitmap(source, 0, 0);
##

#SeeAlso postRotate setRotate

#Method ##

# ------------------------------------------------------------------------------

#Method void preSkew(SkScalar kx, SkScalar ky, SkScalar px, SkScalar py)
#In Set
#In Operators
#Line # pre-multiplies Matrix by skew ##
#Populate

#Example
#Image 3
SkMatrix matrix;
SkPoint bitmapBounds[4], perspect[4] = {{50, 10}, {180, 40}, {236, 176}, {10, 206}};
SkRect::Make(source.bounds()).toQuad(bitmapBounds);
matrix.setPolyToPoly(bitmapBounds, perspect, 4);
matrix.preSkew(.5f, 0, source.width() / 2, source.height() / 2);
canvas->concat(matrix);
canvas->drawBitmap(source, 0, 0);
##

#SeeAlso postSkew setSkew

#Method ##

# ------------------------------------------------------------------------------

#Method void preSkew(SkScalar kx, SkScalar ky)
#Populate

#Example
#Image 3
SkMatrix matrix;
SkPoint bitmapBounds[4], perspect[4] = {{50, 10}, {180, 40}, {236, 176}, {10, 206}};
SkRect::Make(source.bounds()).toQuad(bitmapBounds);
matrix.setPolyToPoly(bitmapBounds, perspect, 4);
matrix.preSkew(.5f, 0);
canvas->concat(matrix);
canvas->drawBitmap(source, 0, 0);
##

#SeeAlso postSkew setSkew

#Method ##

# ------------------------------------------------------------------------------

#Method void preConcat(const SkMatrix& other)
#In Set
#In Operators
#Line # pre-multiplies Matrix by Matrix parameter ##
#Populate

#Example
#Image 3
#Description
setPolyToPoly creates perspective matrices, one the inverse of the other.
Multiplying the matrix by its inverse turns into an identity matrix.
##
SkMatrix matrix, matrix2;
SkPoint bitmapBounds[4], perspect[4] = {{50, 10}, {180, 40}, {236, 176}, {10, 206}};
SkRect::Make(source.bounds()).toQuad(bitmapBounds);
matrix.setPolyToPoly(bitmapBounds, perspect, 4);
matrix2.setPolyToPoly(perspect, bitmapBounds, 4);
matrix.preConcat(matrix2);
canvas->concat(matrix);
canvas->drawBitmap(source, 0, 0);
##

#SeeAlso postConcat setConcat Concat

#Method ##

# ------------------------------------------------------------------------------

#Method void postTranslate(SkScalar dx, SkScalar dy)
#In Set
#In Operators
#Line # post-multiplies Matrix by translation ##
#Populate

#Example
#Height 160
#Description
Compare with preTranslate example.
##
    SkPaint paint;
    paint.setAntiAlias(true);
    SkRect rect = {20, 20, 100, 100};
    for (int i = 0; i < 2; ++i ) {
        SkMatrix matrix;
        i == 0 ? matrix.reset(): matrix.setRotate(25, rect.centerX(), 320);
        {
            SkAutoCanvasRestore acr(canvas, true);
            canvas->concat(matrix);
            paint.setColor(SK_ColorGRAY);
            canvas->drawRect(rect, paint);
        }
        paint.setColor(SK_ColorRED);
        for (int j = 0; j < 2; ++j ) {
            SkAutoCanvasRestore acr(canvas, true);
            matrix.postTranslate(40, 40);
            canvas->concat(matrix);
            canvas->drawCircle(0, 0, 3, paint);
        }
    }
##

#SeeAlso preTranslate setTranslate MakeTrans

#Method ##

# ------------------------------------------------------------------------------

#Method void postScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py)
#In Set
#In Operators
#Line # post-multiplies Matrix by scale ##
#Populate

#Example
#Image 3
SkMatrix matrix;
SkPoint bitmapBounds[4], perspect[4] = {{50, 10}, {180, 40}, {236, 176}, {10, 206}};
SkRect::Make(source.bounds()).toQuad(bitmapBounds);
matrix.setPolyToPoly(bitmapBounds, perspect, 4);
matrix.postScale(.75f, 1.5f, source.width() / 2, source.height() / 2);
canvas->concat(matrix);
canvas->drawBitmap(source, 0, 0);
##

#SeeAlso preScale setScale MakeScale

##

# ------------------------------------------------------------------------------

#Method void postScale(SkScalar sx, SkScalar sy)
#Populate

#Example
#Image 3
SkMatrix matrix;
SkPoint bitmapBounds[4], perspect[4] = {{50, 10}, {180, 40}, {236, 176}, {10, 206}};
SkRect::Make(source.bounds()).toQuad(bitmapBounds);
matrix.setPolyToPoly(bitmapBounds, perspect, 4);
matrix.postScale(.75f, 1.5f);
canvas->concat(matrix);
canvas->drawBitmap(source, 0, 0);
##

#SeeAlso preScale setScale MakeScale

##

# ------------------------------------------------------------------------------

#Method bool postIDiv(int divx, int divy)
#In Set
#In Operators
#Line # post-multiplies Matrix by inverse scale ##
Sets Matrix to Matrix constructed from scaling by (1/divx, 1/divy),
multiplied by Matrix.

Returns false if either divx or divy is zero.

Given:

#Code
#Literal
         | J K L |                   | sx  0  0 |
Matrix = | M N O |,  I(divx, divy) = |  0 sy  0 |
         | P Q R |                   |  0  0  1 |
##

where

#Code
#Literal
sx = 1 / divx
sy = 1 / divy
##

sets Matrix to:

#Code
#Literal
                         | sx  0  0 | | J K L |   | sx*J sx*K sx*L |
I(divx, divy) * Matrix = |  0 sy  0 | | M N O | = | sy*M sy*N sy*O |
                         |  0  0  1 | | P Q R |   |    P    Q    R |
##

#Param divx  integer divisor for inverse scale on x-axis ##
#Param divy  integer divisor for inverse scale on y-axis ##

#Return  true on successful scale ##

#Example
#Image 3
SkMatrix matrix;
SkPoint bitmapBounds[4], perspect[4] = {{50, 10}, {180, 40}, {236, 176}, {10, 206}};
SkRect::Make(source.bounds()).toQuad(bitmapBounds);
matrix.setPolyToPoly(bitmapBounds, perspect, 4);
matrix.postIDiv(1, 2);
canvas->concat(matrix);
canvas->drawBitmap(source, 0, 0);
##

#SeeAlso postScale MakeScale

##

# ------------------------------------------------------------------------------

#Method void postRotate(SkScalar degrees, SkScalar px, SkScalar py)
#In Set
#In Operators
#Line # post-multiplies Matrix by rotation ##
#Populate

#Example
#Image 3
SkMatrix matrix;
SkPoint bitmapBounds[4], perspect[4] = {{50, 10}, {180, 40}, {236, 176}, {10, 206}};
SkRect::Make(source.bounds()).toQuad(bitmapBounds);
matrix.setPolyToPoly(bitmapBounds, perspect, 4);
matrix.postRotate(45, source.width() / 2, source.height() / 2);
canvas->concat(matrix);
canvas->drawBitmap(source, 0, 0);
##

#SeeAlso preRotate setRotate

##

# ------------------------------------------------------------------------------

#Method void postRotate(SkScalar degrees)
#Populate

#Example
#Image 3
SkMatrix matrix;
SkPoint bitmapBounds[4], perspect[4] = {{50, 10}, {180, 40}, {236, 176}, {10, 206}};
SkRect::Make(source.bounds()).toQuad(bitmapBounds);
matrix.setPolyToPoly(bitmapBounds, perspect, 4);
matrix.postRotate(45);
canvas->concat(matrix);
canvas->drawBitmap(source, 0, 0);
##

#SeeAlso preRotate setRotate

##

# ------------------------------------------------------------------------------

#Method void postSkew(SkScalar kx, SkScalar ky, SkScalar px, SkScalar py)
#In Set
#In Operators
#Line # post-multiplies Matrix by skew ##
#Populate

#Example
#Image 3
SkMatrix matrix;
SkPoint bitmapBounds[4], perspect[4] = {{50, 10}, {180, 40}, {236, 176}, {10, 206}};
SkRect::Make(source.bounds()).toQuad(bitmapBounds);
matrix.setPolyToPoly(bitmapBounds, perspect, 4);
matrix.postSkew(.5f, 0, source.width() / 2, source.height() / 2);
canvas->concat(matrix);
canvas->drawBitmap(source, 0, 0);
##

#SeeAlso preSkew setSkew

##

# ------------------------------------------------------------------------------

#Method void postSkew(SkScalar kx, SkScalar ky)
#Populate

#Example
#Image 3
SkMatrix matrix;
SkPoint bitmapBounds[4], perspect[4] = {{50, 10}, {180, 40}, {236, 176}, {10, 206}};
SkRect::Make(source.bounds()).toQuad(bitmapBounds);
matrix.setPolyToPoly(bitmapBounds, perspect, 4);
matrix.postSkew(.5f, 0);
canvas->concat(matrix);
canvas->drawBitmap(source, 0, 0);
##

#SeeAlso preSkew setSkew

##

# ------------------------------------------------------------------------------

#Method void postConcat(const SkMatrix& other)
#In Set
#In Operators
#Line # post-multiplies Matrix by Matrix parameter ##
#Populate

#Example
#Image 3
#Height 64
SkMatrix matrix;
SkPoint bitmapBounds[4], perspect[4] = {{50, 10}, {180, 40}, {236, 176}, {10, 206}};
SkRect::Make(source.bounds()).toQuad(bitmapBounds);
matrix.setPolyToPoly(bitmapBounds, perspect, 4);
matrix.postConcat(matrix);
canvas->concat(matrix);
canvas->drawBitmap(source, 0, 0);
##

#SeeAlso preConcat setConcat Concat

##

# ------------------------------------------------------------------------------

#Enum ScaleToFit
#Line # options to map Rects ##
#Code
    enum ScaleToFit {
        kFill_ScaleToFit,
        kStart_ScaleToFit,
        kCenter_ScaleToFit,
        kEnd_ScaleToFit,
    };
##

ScaleToFit describes how Matrix is constructed to map one Rect to another.
ScaleToFit may allow Matrix to have unequal horizontal and vertical scaling,
or may restrict Matrix to square scaling. If restricted, ScaleToFit specifies
how Matrix maps to the side or center of the destination Rect.

#Const kFill_ScaleToFit 0
#Line # scales about x-axis and y-axis to fill destination Rect ##
    Computes Matrix that scales about x-axis and y-axis independently, so that
    source Rect is mapped to completely fill destination Rect. The aspect ratio
    of source Rect may change.
##
#Const kStart_ScaleToFit 1
#Line # scales and aligns to left and top ##
    Computes Matrix that maintains source Rect aspect ratio, mapping source Rect
    width or height to destination Rect. Aligns mapping to left and top edges
    of destination Rect.
##
#Const kCenter_ScaleToFit 2
#Line # scales and aligns to center ##
    Computes Matrix that maintains source Rect aspect ratio, mapping source Rect
    width or height to destination Rect. Aligns mapping to center of destination
    Rect.
##
#Const kEnd_ScaleToFit 3
#Line # scales and aligns to right and bottom ##
    Computes Matrix that maintains source Rect aspect ratio, mapping source Rect
    width or height to destination Rect. Aligns mapping to right and bottom
    edges of destination Rect.
##

#Example
   const char* labels[] = { "Fill", "Start", "Center", "End" };
   SkRect rects[] = {{5, 5, 59, 59}, {5, 74, 59, 108}, {10, 123, 44, 172}, {10, 187, 54, 231}};
   SkRect bounds;
   source.getBounds(&bounds);
   SkPaint paint;
   paint.setAntiAlias(true);
   for (auto fit : { SkMatrix::kFill_ScaleToFit, SkMatrix::kStart_ScaleToFit,
                     SkMatrix::kCenter_ScaleToFit, SkMatrix::kEnd_ScaleToFit } ) {
       for (auto rect : rects ) {
           canvas->drawRect(rect, paint);
           SkMatrix matrix;
           if (!matrix.setRectToRect(bounds, rect, fit)) {
               continue;
           }
           SkAutoCanvasRestore acr(canvas, true);
           canvas->concat(matrix);
           canvas->drawBitmap(source, 0, 0);
       }
       canvas->drawString(labels[fit], 10, 255, paint);
       canvas->translate(64, 0);
   }
##

#SeeAlso setRectToRect MakeRectToRect setPolyToPoly

##

# ------------------------------------------------------------------------------

#Method bool setRectToRect(const SkRect& src, const SkRect& dst, ScaleToFit stf)
#In Set
#Line # sets to map one Rect to another ##
#Populate

#Example
    const SkRect srcs[] = { {0, 0, 0, 0}, {1, 2, 3, 4} };
    const SkRect dsts[] = { {0, 0, 0, 0}, {5, 6, 8, 9} };
    for (auto src : srcs) {
        for (auto dst : dsts) {
             SkMatrix matrix;
             matrix.setAll(-1, -1, -1, -1, -1, -1, -1, -1, -1);
             bool success = matrix.setRectToRect(src, dst, SkMatrix::kFill_ScaleToFit);
             SkDebugf("src: %g, %g, %g, %g  dst: %g, %g, %g, %g  success: %s\n",
                      src.fLeft, src.fTop, src.fRight, src.fBottom,
                      dst.fLeft, dst.fTop, dst.fRight, dst.fBottom, success ? "true" : "false");
             matrix.dump();
        }
    }
#StdOut
src: 0, 0, 0, 0  dst: 0, 0, 0, 0  success: false
[  1.0000   0.0000   0.0000][  0.0000   1.0000   0.0000][  0.0000   0.0000   1.0000]
src: 0, 0, 0, 0  dst: 5, 6, 8, 9  success: false
[  1.0000   0.0000   0.0000][  0.0000   1.0000   0.0000][  0.0000   0.0000   1.0000]
src: 1, 2, 3, 4  dst: 0, 0, 0, 0  success: true
[  0.0000   0.0000   0.0000][  0.0000   0.0000   0.0000][  0.0000   0.0000   1.0000]
src: 1, 2, 3, 4  dst: 5, 6, 8, 9  success: true
[  1.5000   0.0000   3.5000][  0.0000   1.5000   3.0000][  0.0000   0.0000   1.0000]
##
##

#SeeAlso MakeRectToRect ScaleToFit setPolyToPoly SkRect::isEmpty

##

# ------------------------------------------------------------------------------

#Method static SkMatrix MakeRectToRect(const SkRect& src, const SkRect& dst, ScaleToFit stf)
#In Constructors
#Line # constructs from source Rect to destination Rect ##
#Populate

#Example
    const SkRect srcs[] = { {0, 0, 0, 0}, {1, 2, 3, 4} };
    const SkRect dsts[] = { {0, 0, 0, 0}, {5, 6, 8, 9} };
    for (auto src : srcs) {
        for (auto dst : dsts) {
             SkMatrix matrix = SkMatrix::MakeRectToRect(src, dst, SkMatrix::kFill_ScaleToFit);
             SkDebugf("src: %g, %g, %g, %g  dst: %g, %g, %g, %g\n",
                      src.fLeft, src.fTop, src.fRight, src.fBottom,
                      dst.fLeft, dst.fTop, dst.fRight, dst.fBottom);
             matrix.dump();
        }
    }
#StdOut
src: 0, 0, 0, 0  dst: 0, 0, 0, 0
[  1.0000   0.0000   0.0000][  0.0000   1.0000   0.0000][  0.0000   0.0000   1.0000]
src: 0, 0, 0, 0  dst: 5, 6, 8, 9
[  1.0000   0.0000   0.0000][  0.0000   1.0000   0.0000][  0.0000   0.0000   1.0000]
src: 1, 2, 3, 4  dst: 0, 0, 0, 0
[  0.0000   0.0000   0.0000][  0.0000   0.0000   0.0000][  0.0000   0.0000   1.0000]
src: 1, 2, 3, 4  dst: 5, 6, 8, 9
[  1.5000   0.0000   3.5000][  0.0000   1.5000   3.0000][  0.0000   0.0000   1.0000]
##
##

#SeeAlso setRectToRect ScaleToFit setPolyToPoly SkRect::isEmpty

##

# ------------------------------------------------------------------------------

#Method bool setPolyToPoly(const SkPoint src[], const SkPoint dst[], int count)
#In Set
#Line # sets to map one to four points to an equal array of points ##
#Populate

#Example
    const SkPoint src[] = { { 0, 0}, {30,   0}, {30, -30}, { 0, -30} };
    const SkPoint dst[] = { {50, 0}, {80, -10}, {90, -30}, {60, -40} };
    SkPaint blackPaint;
    blackPaint.setAntiAlias(true);
    SkFont font(nullptr, 42);
    SkPaint redPaint = blackPaint;
    redPaint.setColor(SK_ColorRED);
    for (int count : { 1, 2, 3, 4 } ) {
        canvas->translate(35, 55);
        for (int index = 0; index < count; ++index) {
            canvas->drawCircle(src[index], 3, blackPaint);
            canvas->drawCircle(dst[index], 3, blackPaint);
            if (index > 0) {
                canvas->drawLine(src[index], src[index - 1], font, blackPaint);
                canvas->drawLine(dst[index], dst[index - 1], font, blackPaint);
            }
        }
        SkMatrix matrix;
        matrix.setPolyToPoly(src, dst, count);
        canvas->drawString("A", src[0].fX, src[0].fY, font, redPaint);
        SkAutoCanvasRestore acr(canvas, true);
        canvas->concat(matrix);
        canvas->drawString("A", src[0].fX, src[0].fY, font, redPaint);
    }
##

#SeeAlso setRectToRect MakeRectToRect

##

# ------------------------------------------------------------------------------

#Method bool invert(SkMatrix* inverse) const
#In Operators
#Line # returns inverse, if possible ##
#Populate

#Example
#Height 128
    const SkPoint src[] = { { 10, 120}, {120, 120}, {120, 10}, {  10, 10} };
    const SkPoint dst[] = { {150, 120}, {200, 100}, {240, 30}, { 130, 40} };
    SkPaint paint;
    paint.setAntiAlias(true);
    SkMatrix matrix;
    matrix.setPolyToPoly(src, dst, 4);
    canvas->drawPoints(SkCanvas::kPolygon_PointMode, 4, src, paint);
    canvas->drawPoints(SkCanvas::kPolygon_PointMode, 4, dst, paint);
    paint.setColor(SK_ColorBLUE);
    paint.setStrokeWidth(3);
    paint.setStrokeCap(SkPaint::kRound_Cap);
    canvas->drawPoints(SkCanvas::kPoints_PointMode, 4, dst, paint);
    if (matrix.invert(&matrix)) {
        canvas->concat(matrix);
        canvas->drawPoints(SkCanvas::kPoints_PointMode, 4, dst, paint);
    }
##

#SeeAlso Concat

##

# ------------------------------------------------------------------------------

#Method static void SetAffineIdentity(SkScalar affine[6])
#In Constructors
#Line # sets 3x2 array to identity ##
#Populate

#Example
    SkScalar affine[6];
    SkMatrix::SetAffineIdentity(affine);
    const char* names[] = { "ScaleX", "SkewY", "SkewX", "ScaleY", "TransX", "TransY" };
    for (int i = 0; i < 6; ++i) {
        SkDebugf("%s: %g ", names[i], affine[i]);
    }
    SkDebugf("\n");
#StdOut
ScaleX: 1 SkewY: 0 SkewX: 0 ScaleY: 1 TransX: 0 TransY: 0
##
##

#SeeAlso setAffine asAffine

##

# ------------------------------------------------------------------------------

#Method bool asAffine(SkScalar affine[6]) const
#In Constructors
#Line # copies to 3x2 array ##
#Populate

#Example
SkMatrix matrix;
matrix.setAll(2, 3, 4, 5, 6, 7, 0, 0, 1);
SkScalar affine[6];
if (matrix.asAffine(affine)) {
    const char* names[] = { "ScaleX", "SkewY", "SkewX", "ScaleY", "TransX", "TransY" };
    for (int i = 0; i < 6; ++i) {
        SkDebugf("%s: %g ", names[i], affine[i]);
    }
    SkDebugf("\n");
}
#StdOut
ScaleX: 2 SkewY: 5 SkewX: 3 ScaleY: 6 TransX: 4 TransY: 7
##
##

#SeeAlso setAffine SetAffineIdentity

##

# ------------------------------------------------------------------------------

#Method void setAffine(const SkScalar affine[6])
#In Constructors
#In Set
#Line # sets left two columns ##
#Populate

#Example
SkMatrix matrix;
matrix.setAll(2, 3, 4, 5, 6, 7, 0, 0, 1);
SkScalar affine[6];
if (matrix.asAffine(affine)) {
    const char* names[] = { "ScaleX", "SkewY", "SkewX", "ScaleY", "TransX", "TransY" };
    for (int i = 0; i < 6; ++i) {
        SkDebugf("%s: %g ", names[i], affine[i]);
    }
    SkDebugf("\n");
    matrix.reset();
    matrix.setAffine(affine);
    matrix.dump();
}
#StdOut
ScaleX: 2 SkewY: 5 SkewX: 3 ScaleY: 6 TransX: 4 TransY: 7
[  2.0000   3.0000   4.0000][  5.0000   6.0000   7.0000][  0.0000   0.0000   1.0000]
##
##

#SeeAlso asAffine SetAffineIdentity

##

# ------------------------------------------------------------------------------
#Subtopic Transform
#Line # map points with Matrix ##
##

#Method void mapPoints(SkPoint dst[], const SkPoint src[], int count) const
#In Transform
#Line # maps Point array ##
#Populate

#Example
    SkMatrix matrix;
    matrix.reset();
    const int count = 4;
    SkPoint src[count];
    matrix.mapRectToQuad(src, {40, 70, 180, 220} );
    SkPaint paint;
    paint.setARGB(77, 23, 99, 154);
    for (int i = 0; i < 5; ++i) {
        SkPoint dst[count];
        matrix.mapPoints(dst, src, count);
        canvas->drawPoints(SkCanvas::kPolygon_PointMode, count, dst, paint);
        matrix.preRotate(35, 128, 128);
    }
##

#SeeAlso mapXY mapHomogeneousPoints mapVectors

##

# ------------------------------------------------------------------------------

#Method void mapPoints(SkPoint pts[], int count) const
#Populate

#Example
    SkMatrix matrix;
    matrix.setRotate(35, 128, 128);
    const int count = 4;
    SkPoint pts[count];
    matrix.mapRectToQuad(pts, {40, 70, 180, 220} );
    SkPaint paint;
    paint.setARGB(77, 23, 99, 154);
    for (int i = 0; i < 5; ++i) {
        canvas->drawPoints(SkCanvas::kPolygon_PointMode, count, pts, paint);
        matrix.mapPoints(pts, count);
    }
##

#SeeAlso mapXY mapHomogeneousPoints mapVectors

##

# ------------------------------------------------------------------------------

#Method void mapHomogeneousPoints(SkPoint3 dst[], const SkPoint3 src[], int count) const
#In Transform
#Line # maps Point3 array ##
#Populate

#Example
    SkPoint3 src[] = {{3, 3, 1}, {8, 2, 2}, {5, 0, 4}, {0, 1, 3},
                      {3, 7, 1}, {8, 6, 2}, {5, 4, 4}, {0, 5, 3}};
    int lines[] = { 0, 1, 1, 2, 2, 3, 3, 0, 4, 5, 5, 6, 6, 7, 7, 4, 0, 4, 1, 5, 2, 6, 3, 7 };
    constexpr int count = SK_ARRAY_COUNT(src);
    auto debugster = [=](SkPoint3 src[]) -> void {
    for (size_t i = 0; i < SK_ARRAY_COUNT(lines); i += 2) {
        const SkPoint3& s = src[lines[i]];
        const SkPoint3& e = src[lines[i + 1]];
        SkPaint paint;
        paint.setARGB(77, 23, 99, 154);
        canvas->drawLine(s.fX / s.fZ, s.fY / s.fZ, e.fX / e.fZ, e.fY / e.fZ, paint);
    }
    };
    canvas->save();
    canvas->translate(5, 5);
    canvas->scale(15, 15);
    debugster(src);
    canvas->restore();
    canvas->translate(128, 128);
    SkMatrix matrix;
    matrix.setAll(15, 0, 0, 0, 15, 0, -0.08, 0.04, 1);
    matrix.mapHomogeneousPoints(src, src, count);
    debugster(src);
##

#SeeAlso mapPoints mapXY mapVectors

##

# ------------------------------------------------------------------------------

#Method void mapXY(SkScalar x, SkScalar y, SkPoint* result) const
#In Transform
#Line # maps Point ##
#Populate

#Example
    SkPaint paint;
    paint.setAntiAlias(true);
    SkMatrix matrix;
    matrix.setRotate(60, 128, 128);
    SkPoint lines[] = {{50, 50}, {150, 50}, {150, 150}};
    for (size_t i = 0; i < SK_ARRAY_COUNT(lines); ++i) {
        SkPoint pt;
        matrix.mapXY(lines[i].fX, lines[i].fY, &pt);
        canvas->drawCircle(pt.fX, pt.fY, 3, paint);
    }
    canvas->concat(matrix);
    canvas->drawPoints(SkCanvas::kPolygon_PointMode, SK_ARRAY_COUNT(lines), lines, paint);
##

#SeeAlso mapPoints mapVectors

##

# ------------------------------------------------------------------------------

#Method SkPoint mapXY(SkScalar x, SkScalar y) const
#Populate

#Example
#Image 4
SkMatrix matrix;
SkPoint bitmapBounds[4], perspect[4] = {{50, 10}, {180, 40}, {236, 176}, {30, 206}};
SkRect::Make(source.bounds()).toQuad(bitmapBounds);
matrix.setPolyToPoly(bitmapBounds, perspect, 4);
SkPaint paint;
paint.setAntiAlias(true);
paint.setStrokeWidth(3);
for (int x : { 0, source.width() } ) {
    for (int y : { 0, source.height() } ) {
        canvas->drawPoint(matrix.mapXY(x, y), paint);
    }
}
canvas->concat(matrix);
canvas->drawBitmap(source, 0, 0);
##

#SeeAlso mapPoints mapVectors

##

# ------------------------------------------------------------------------------

#Method void mapVectors(SkVector dst[], const SkVector src[], int count) const
#In Transform
#Line # maps Vector array ##
#Populate

#Example
    SkPaint paint;
    paint.setAntiAlias(true);
    paint.setStyle(SkPaint::kStroke_Style);
    SkMatrix matrix;
    matrix.reset();
    const SkVector radii[] = {{8, 4}, {9, 1}, {6, 2}, {7, 3}};
    for (int i = 0; i < 4; ++i) {
        SkVector rScaled[4];
        matrix.preScale(1.5f, 2.f);
        matrix.mapVectors(rScaled, radii, SK_ARRAY_COUNT(radii));
        SkRRect rrect;
        rrect.setRectRadii({20, 20, 180, 70}, rScaled);
        canvas->drawRRect(rrect, paint);
        canvas->translate(0, 60);
    }
##

#SeeAlso mapVector mapPoints mapXY

##

# ------------------------------------------------------------------------------

#Method void mapVectors(SkVector vecs[], int count) const
#Populate

#Example
    SkPaint paint;
    paint.setAntiAlias(true);
    paint.setStyle(SkPaint::kStroke_Style);
    SkMatrix matrix;
    matrix.setScale(2, 3);
    SkVector radii[] = {{7, 7}, {3, 3}, {2, 2}, {4, 0}};
    for (int i = 0; i < 4; ++i) {
        SkRRect rrect;
        rrect.setRectRadii({20, 20, 180, 70}, radii);
        canvas->drawRRect(rrect, paint);
        canvas->translate(0, 60);
        matrix.mapVectors(radii, SK_ARRAY_COUNT(radii));
    }
##

#SeeAlso mapVector mapPoints mapXY

##

# ------------------------------------------------------------------------------

#Method void mapVector(SkScalar dx, SkScalar dy, SkVector* result) const
#In Transform
#Line # maps Vector ##
#Populate

#Example
    SkPaint paint;
    paint.setColor(SK_ColorGREEN);
    SkFont font(nullptr, 48);
    SkMatrix matrix;
    matrix.setRotate(90);
    SkVector offset = { 7, 7 };
    for (int i = 0; i < 4; ++i) {
        paint.setImageFilter(SkDropShadowImageFilter::Make(offset.fX, offset.fY, 3, 3,
              SK_ColorBLUE, SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode, nullptr));
        matrix.mapVector(offset.fX, offset.fY, &offset);
        canvas->translate(0, 60);
        canvas->drawString("Text", 50, 0, font, paint);
    }
##

#SeeAlso mapVectors mapPoints mapXY

##

# ------------------------------------------------------------------------------

#Method SkVector mapVector(SkScalar dx, SkScalar dy) const
#Populate

#Example
    SkPaint paint;
    paint.setColor(SK_ColorGREEN);
    SkFont font(nullptr, 48);
    SkMatrix matrix;
    matrix.setRotate(90);
    SkVector offset = { 7, 7 };
    for (int i = 0; i < 4; ++i) {
        paint.setImageFilter(SkDropShadowImageFilter::Make(offset.fX, offset.fY, 3, 3,
              SK_ColorBLUE, SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode, nullptr));
        offset = matrix.mapVector(offset.fX, offset.fY);
        canvas->translate(0, 60);
        canvas->drawString("Text", 50, 0, font, paint);
    }
##

#SeeAlso mapVectors mapPoints mapXY

##

# ------------------------------------------------------------------------------

#Method bool mapRect(SkRect* dst, const SkRect& src) const
#In Transform
#Line # returns bounds of mapped Rect ##
#Populate

#Example
    SkPaint paint;
    paint.setAntiAlias(true);
    SkMatrix matrix;
    matrix.setRotate(45, 128, 128);
    SkRect rotatedBounds, bounds = {40, 50, 190, 200};
    matrix.mapRect(&rotatedBounds, bounds );
    paint.setColor(SK_ColorGRAY);
    canvas->drawRect(rotatedBounds, paint);
    canvas->concat(matrix);
    paint.setColor(SK_ColorRED);
    canvas->drawRect(bounds, paint);
##

#SeeAlso mapPoints rectStaysRect

##

# ------------------------------------------------------------------------------

#Method bool mapRect(SkRect* rect) const
#Populate

#Example
    SkPaint paint;
    paint.setAntiAlias(true);
    SkMatrix matrix;
    matrix.setRotate(45, 128, 128);
    SkRect bounds = {40, 50, 190, 200};
    matrix.mapRect(&bounds);
    paint.setColor(SK_ColorGRAY);
    canvas->drawRect(bounds, paint);
    canvas->concat(matrix);
    paint.setColor(SK_ColorRED);
    canvas->drawRect({40, 50, 190, 200}, paint);
##

#SeeAlso mapRectScaleTranslate mapPoints rectStaysRect

##

# ------------------------------------------------------------------------------

#Method SkRect mapRect(const SkRect& src) const
#Populate

#Example
  SkRect rect{110, 50, 180, 100};
  SkMatrix matrix;
  matrix.setRotate(50, 28, 28);
  SkRect mapped = matrix.mapRect(rect);
  SkPaint paint;
  paint.setAntiAlias(true);
  paint.setStyle(SkPaint::kStroke_Style);
  canvas->drawRect(rect, paint);
  canvas->drawRect(mapped, paint);
  canvas->concat(matrix);
  canvas->drawRect(rect, paint);
##

#SeeAlso mapRectToQuad mapRectScaleTranslate
#Method ##

# ------------------------------------------------------------------------------

#Method void mapRectToQuad(SkPoint dst[4], const SkRect& rect) const
#In Transform
#Line # maps Rect to Point array ##
#Populate

#Example
#Height 192
    SkPaint paint;
    paint.setAntiAlias(true);
    SkMatrix matrix;
    matrix.setRotate(60, 128, 128);
    SkRect rect = {50, 50, 150, 150};
    SkPoint pts[4];
    matrix.mapRectToQuad(pts, rect);
    for (int i = 0; i < 4; ++i) {
        canvas->drawCircle(pts[i].fX, pts[i].fY, 3, paint);
    }
    canvas->concat(matrix);
    paint.setStyle(SkPaint::kStroke_Style);
    canvas->drawRect(rect, paint);
##

#SeeAlso mapRect mapRectScaleTranslate

##

# ------------------------------------------------------------------------------

#Method void mapRectScaleTranslate(SkRect* dst, const SkRect& src) const
#In Transform
#Line # returns bounds of mapped Rect ##
#Populate

#Example
    SkPaint paint;
    SkMatrix matrix;
    SkRect rect = {100, 50, 150, 180};
    matrix.setScale(2, .5f, rect.centerX(), rect.centerY());
    SkRect rotated;
    matrix.mapRectScaleTranslate(&rotated, rect);
    paint.setStyle(SkPaint::kStroke_Style);
    canvas->drawRect(rect, paint);
    paint.setColor(SK_ColorRED);
    canvas->drawRect(rotated, paint);
##

#SeeAlso mapRect mapRectToQuad isScaleTranslate rectStaysRect

##

# ------------------------------------------------------------------------------

#Method SkScalar mapRadius(SkScalar radius) const
#In Transform
#Line # returns mean radius of mapped Circle ##
#Populate

#Example
#Description
The area enclosed by a square with sides equal to mappedRadius is the same as
the area enclosed by the ellipse major and minor axes.
##
  SkPaint paint;
  paint.setAntiAlias(true);
  SkMatrix matrix;
  const SkPoint center = {108, 93};
  matrix.setScale(2, .5f, center.fX, center.fY);
  matrix.postRotate(45, center.fX, center.fY);
  const SkScalar circleRadius = 50;
  SkScalar mappedRadius = matrix.mapRadius(circleRadius);
  SkVector minorAxis, majorAxis;
  matrix.mapVector(0, circleRadius, &minorAxis);
  matrix.mapVector(circleRadius, 0, &majorAxis);
  SkString mappedArea;
  mappedArea.printf("area = %g", mappedRadius * mappedRadius);
  canvas->drawString(mappedArea, 145, 250, paint);
  canvas->drawString("mappedRadius", center.fX + mappedRadius + 3, center.fY, paint);
  paint.setColor(SK_ColorRED);
  SkString axArea;
  axArea.printf("area = %g", majorAxis.length() * minorAxis.length());
  paint.setStyle(SkPaint::kFill_Style);
  canvas->drawString(axArea, 15, 250, paint);
  paint.setStyle(SkPaint::kStroke_Style);
  canvas->drawRect({10, 200, 10 + majorAxis.length(), 200 + minorAxis.length()}, paint);
  paint.setColor(SK_ColorBLACK);
  canvas->drawLine(center.fX, center.fY, center.fX + mappedRadius, center.fY, paint);
  canvas->drawLine(center.fX, center.fY, center.fX, center.fY + mappedRadius, paint);
  canvas->drawRect({140, 180, 140 + mappedRadius, 180 + mappedRadius}, paint);
  canvas->concat(matrix);
  canvas->drawCircle(center.fX, center.fY, circleRadius, paint);
  paint.setColor(SK_ColorRED);
  canvas->drawLine(center.fX, center.fY, center.fX + circleRadius, center.fY, paint);
  canvas->drawLine(center.fX, center.fY, center.fX, center.fY + circleRadius, paint);
##

#SeeAlso mapVector

##

# ------------------------------------------------------------------------------
#Method bool isFixedStepInX() const
#In Property
#Line # returns if transformation supports fixed step on x-axis ##
#Populate

#Example
    SkMatrix matrix;
    for (SkScalar px : { 0.0f, 0.1f } ) {
        for (SkScalar py : { 0.0f, 0.1f } ) {
            for (SkScalar sy : { 1, 2 } ) {
                matrix.setAll(1, 0, 0,   0, sy, 0,   px, py, 1);
                matrix.dump();
                SkDebugf("isFixedStepInX: %s\n", matrix.isFixedStepInX() ? "true" : "false");
            }
        }
    }
#StdOut
[  1.0000   0.0000   0.0000][  0.0000   1.0000   0.0000][  0.0000   0.0000   1.0000]
isFixedStepInX: true
[  1.0000   0.0000   0.0000][  0.0000   2.0000   0.0000][  0.0000   0.0000   1.0000]
isFixedStepInX: true
[  1.0000   0.0000   0.0000][  0.0000   1.0000   0.0000][  0.0000   0.1000   1.0000]
isFixedStepInX: true
[  1.0000   0.0000   0.0000][  0.0000   2.0000   0.0000][  0.0000   0.1000   1.0000]
isFixedStepInX: true
[  1.0000   0.0000   0.0000][  0.0000   1.0000   0.0000][  0.1000   0.0000   1.0000]
isFixedStepInX: false
[  1.0000   0.0000   0.0000][  0.0000   2.0000   0.0000][  0.1000   0.0000   1.0000]
isFixedStepInX: false
[  1.0000   0.0000   0.0000][  0.0000   1.0000   0.0000][  0.1000   0.1000   1.0000]
isFixedStepInX: false
[  1.0000   0.0000   0.0000][  0.0000   2.0000   0.0000][  0.1000   0.1000   1.0000]
isFixedStepInX: false
##
##

#SeeAlso fixedStepInX getType

##

# ------------------------------------------------------------------------------

#Method SkVector fixedStepInX(SkScalar y) const
#In Property
#Line # returns step on x-axis for a position on y-axis ##
#Populate

#Example
#Image 3
    SkMatrix matrix;
    const SkPoint center = { 128, 128 };
    matrix.setScale(20, 25, center.fX, center.fY);
    matrix.postRotate(75, center.fX, center.fY);
    {
       SkAutoCanvasRestore acr(canvas, true);
       canvas->concat(matrix);
       canvas->drawBitmap(source, 0, 0);
    }
    if (matrix.isFixedStepInX()) {
       SkPaint paint;
       paint.setAntiAlias(true);
       SkVector step = matrix.fixedStepInX(128);
       SkVector end = center + step;
       canvas->drawLine(center, end, paint);
       SkVector arrow = { step.fX + step.fY, step.fY - step.fX};
       arrow = arrow * .25f;
       canvas->drawLine(end, end - arrow, paint);
       canvas->drawLine(end, {end.fX + arrow.fY, end.fY - arrow.fX}, paint);
    }
##

#SeeAlso isFixedStepInX getType

##

# ------------------------------------------------------------------------------

#Method bool cheapEqualTo(const SkMatrix& m) const
#In Operators
#Line # compares Matrix pair using memcmp() ##
#Populate

#Example
    auto debugster = [](const char* prefix, const SkMatrix& a, const SkMatrix& b) -> void {
        SkDebugf("%s: a %c= b a.cheapEqualTo(b): %s\n", prefix,
                 a == b ? '=' : '!', a.cheapEqualTo(b) ? "true" : "false");
    };
    SkMatrix a, b;
    a.setAll(1, 0, 0,   0, 1, 0,  0, 0, 1);
    b.setIdentity();
    debugster("identity", a, b);
    a.setAll(1, -0.0f, 0,   0, 1, 0,  0, 0, 1);
    debugster("neg zero", a, b);
    a.setAll(1, SK_ScalarNaN, 0,   0, 1, 0,  0, 0, 1);
    debugster(" one NaN", a, b);
    b.setAll(1, SK_ScalarNaN, 0,   0, 1, 0,  0, 0, 1);
    debugster("both NaN", a, b);
#StdOut
identity: a == b a.cheapEqualTo(b): true
neg zero: a == b a.cheapEqualTo(b): false
 one NaN: a != b a.cheapEqualTo(b): false
both NaN: a != b a.cheapEqualTo(b): true
##
##

#SeeAlso operator==(const SkMatrix& a, const SkMatrix& b)

##

# ------------------------------------------------------------------------------

#Method bool operator==(const SkMatrix& a, const SkMatrix& b)

#Line # returns true if members are equal ##
#Populate

#Example
    auto debugster = [](const char* prefix, const SkMatrix& a, const SkMatrix& b) -> void {
        SkDebugf("%s: a %c= b a.cheapEqualTo(b): %s\n", prefix,
                 a == b ? '=' : '!', a.cheapEqualTo(b) ? "true" : "false");
    };
    SkMatrix a, b;
    a.setAll(1, 0, 0,   0, 1, 0,  0, 0, 1);
    b.setScale(2, 4);
    b.postScale(0.5f, 0.25f);
    debugster("identity", a, b);
#StdOut
identity: a == b a.cheapEqualTo(b): true
##
##

#SeeAlso  cheapEqualTo operator!=(const SkMatrix& a, const SkMatrix& b)

##

# ------------------------------------------------------------------------------

#Method bool operator!=(const SkMatrix& a, const SkMatrix& b)

#Line # returns true if members are unequal ##
#Populate

#Example
    auto debugster = [](const char* prefix, const SkMatrix& a, const SkMatrix& b) -> void {
        SkDebugf("%s: a %c= b a.cheapEqualTo(b): %s\n", prefix,
                 a != b ? '!' : '=', a.cheapEqualTo(b) ? "true" : "false");
    };
    SkMatrix a, b;
    a.setAll(1, 0, 0,   0, 1, 0,  1, 0, 1);
    if (a.invert(&b)) {
        debugster("identity", a, b);
    }
##

#SeeAlso cheapEqualTo operator==(const SkMatrix& a, const SkMatrix& b)

##

# ------------------------------------------------------------------------------
#Subtopic Utility
#Line # rarely called management functions ##
##

#Method void dump() const
#In Utility
#Line # sends text representation using floats to standard output ##
#Populate

#Example
    SkMatrix matrix;
    matrix.setRotate(45);
    matrix.dump();
    SkMatrix nearlyEqual;
    nearlyEqual.setAll(0.7071f, -0.7071f, 0,   0.7071f, 0.7071f, 0,   0, 0, 1);
    nearlyEqual.dump();
    SkDebugf("matrix %c= nearlyEqual\n", matrix == nearlyEqual ? '=' : '!');
#StdOut
[  0.7071  -0.7071   0.0000][  0.7071   0.7071   0.0000][  0.0000   0.0000   1.0000]
[  0.7071  -0.7071   0.0000][  0.7071   0.7071   0.0000][  0.0000   0.0000   1.0000]
matrix != nearlyEqual
##
##

#SeeAlso SkPath::dump

##

# ------------------------------------------------------------------------------

#Method SkScalar getMinScale() const
#In Property
#Line # returns minimum scaling, if possible ##
#Populate

#Example
    SkMatrix matrix;
    matrix.setScale(42, 24);
    SkDebugf("matrix.getMinScale() %g\n", matrix.getMinScale());
#StdOut
matrix.getMinScale() 24
##
##

#SeeAlso getMaxScale getMinMaxScales

##

# ------------------------------------------------------------------------------

#Method SkScalar getMaxScale() const
#In Property
#Line # returns maximum scaling, if possible ##
#Populate

#Example
    SkMatrix matrix;
    matrix.setScale(42, 24);
    SkDebugf("matrix.getMaxScale() %g\n", matrix.getMaxScale());
#StdOut
matrix.getMaxScale() 42
##
##

#SeeAlso getMinScale getMinMaxScales

##

# ------------------------------------------------------------------------------

#Method bool getMinMaxScales(SkScalar scaleFactors[2]) const
#In Property
#Line # returns minimum and maximum scaling, if possible ##
#Populate

#Example
    SkMatrix matrix;
    matrix.setAll(1, 0, 0,  0, 1, 0,   0, 0, 0);
    if (matrix.invert(&matrix)) {
        SkScalar factor[2] = {2, 2};
        bool result = matrix.getMinMaxScales(factor);
        SkDebugf("matrix.getMinMaxScales() %s %g %g\n",
                result ? "true" : "false", factor[0], factor[1]);
    }
#StdOut
matrix.getMinMaxScales() false 2 2
##
##

#SeeAlso getMinScale getMaxScale

##

# ------------------------------------------------------------------------------

#Method bool decomposeScale(SkSize* scale, SkMatrix* remaining = nullptr) const
#In Property
#Line # separates scale if possible ##
Decomposes Matrix into scale components and whatever remains. Returns false if
Matrix could not be decomposed.

Sets scale to portion of Matrix that scale axes. Sets remaining to Matrix
with scaling factored out. remaining may be passed as nullptr
to determine if Matrix can be decomposed without computing remainder.

Returns true if scale components are found. scale and remaining are
unchanged if Matrix contains perspective; scale factors are not finite, or
are nearly zero.

On success: #Formula # Matrix = scale * Remaining ##.

#Param scale  axes scaling factors; may be nullptr ##
#Param remaining  Matrix without scaling; may be nullptr ##

#Return  true if scale can be computed ##

#Example
    SkMatrix matrix;
    matrix.setRotate(90 * SK_Scalar1);
    matrix.postScale(1.f / 4, 1.f / 2);
    matrix.dump();
    SkSize scale = {SK_ScalarNaN, SK_ScalarNaN};
    SkMatrix remaining;
    remaining.reset();
    bool success = matrix.decomposeScale(&scale, &remaining);
    SkDebugf("success: %s  ", success ? "true" : "false");
    SkDebugf("scale: %g, %g\n", scale.width(), scale.height());
    remaining.dump();
    SkMatrix scaleMatrix = SkMatrix::MakeScale(scale.width(), scale.height());
    SkMatrix combined = SkMatrix::Concat(scaleMatrix, remaining);
    combined.dump();
#StdOut
[  0.0000  -0.2500   0.0000][  0.5000   0.0000   0.0000][  0.0000   0.0000   1.0000]
success: true  scale: 0.5, 0.25
[  0.0000  -0.5000   0.0000][  2.0000   0.0000   0.0000][  0.0000   0.0000   1.0000]
[  0.0000  -0.2500   0.0000][  0.5000   0.0000   0.0000][  0.0000   0.0000   1.0000]
##
##

#SeeAlso setScale MakeScale

##

# ------------------------------------------------------------------------------

#Method static const SkMatrix& I()
#In Constructors
#Line # returns a reference to a const identity Matrix ##
#Populate

#Example
    SkMatrix m1, m2, m3;
    m1.reset();
    m2.setIdentity();
    m3 = SkMatrix::I();
    SkDebugf("m1 %c= m2\n", m1 == m2 ? '=' : '!');
    SkDebugf("m2 %c= m3\n", m1 == m2 ? '=' : '!');
#StdOut
m1 == m2
m2 == m3
##
##

#SeeAlso reset() setIdentity

##

# ------------------------------------------------------------------------------

#Method static const SkMatrix& InvalidMatrix()
#In Constructors
#Line # returns a reference to a const invalid Matrix ##
#Populate

#Example
    SkDebugf("scaleX %g\n", SkMatrix::InvalidMatrix().getScaleX());
#StdOut
scaleX 3.40282e+38
##
##

#SeeAlso getType

##

# ------------------------------------------------------------------------------

#Method static SkMatrix Concat(const SkMatrix& a, const SkMatrix& b)
#In Operators
#Line # returns the concatenation of Matrix pair ##
#Populate

#Example
#Height 64
#Image 4
#Description
setPolyToPoly creates perspective matrices, one the inverse of the other.
Multiplying the matrix by its inverse turns into an identity matrix.
##
SkMatrix matrix, matrix2;
SkPoint bitmapBounds[4], perspect[4] = {{50, 10}, {180, 40}, {236, 176}, {10, 206}};
SkRect::Make(source.bounds()).toQuad(bitmapBounds);
matrix.setPolyToPoly(bitmapBounds, perspect, 4);
matrix2.setPolyToPoly(perspect, bitmapBounds, 4);
SkMatrix concat = SkMatrix::Concat(matrix, matrix2);
canvas->concat(concat);
canvas->drawBitmap(source, 0, 0);
##

#SeeAlso preConcat postConcat

##

# ------------------------------------------------------------------------------

#Method void dirtyMatrixTypeCache()
#In Utility
#Line # sets internal cache to unknown state ##
#Populate

#Example
SkMatrix matrix;
matrix.setIdentity();
SkDebugf("with identity matrix: x = %g\n", matrix.mapXY(24, 42).fX);
SkScalar& skewRef = matrix[SkMatrix::kMSkewX];
skewRef = 0;
SkDebugf("after skew x mod:     x = %g\n", matrix.mapXY(24, 42).fX);
skewRef = 1;
SkDebugf("after 2nd skew x mod: x = %g\n", matrix.mapXY(24, 42).fX);
matrix.dirtyMatrixTypeCache();
SkDebugf("after dirty cache:    x = %g\n", matrix.mapXY(24, 42).fX);
#StdOut
with identity matrix: x = 24
after skew x mod:     x = 24
after 2nd skew x mod: x = 24
after dirty cache:    x = 66
##
##

#SeeAlso operator[](int index) getType

##

# ------------------------------------------------------------------------------

#Method void setScaleTranslate(SkScalar sx, SkScalar sy, SkScalar tx, SkScalar ty)
#In Constructors
#In Set
#Line # sets to scale and translate ##
#Populate

#Example
SkMatrix matrix;
matrix.setScaleTranslate(1, 2, 3, 4);
matrix.dump();
#StdOut
[  1.0000   0.0000   3.0000][  0.0000   2.0000   4.0000][  0.0000   0.0000   1.0000]
##
##

#SeeAlso setScale preTranslate postTranslate

##

# ------------------------------------------------------------------------------

#Method bool isFinite() const
#In Property
#Line # returns if all Matrix values are not infinity, NaN ##
#Populate

#Example
SkMatrix matrix = SkMatrix::MakeTrans(SK_ScalarNaN, 0);
matrix.dump();
SkDebugf("matrix is finite: %s\n", matrix.isFinite() ? "true" : "false");
SkDebugf("matrix %c= matrix\n", matrix == matrix ? '=' : '!');
#StdOut
[  1.0000   0.0000      nan][  0.0000   1.0000   0.0000][  0.0000   0.0000   1.0000]
matrix is finite: false
matrix != matrix
##
##

#SeeAlso operator==

##

#Class SkMatrix ##

#Topic Matrix ##