Matrix

class Matrix

枚举类

TypeMask

enum TypeMask {
    kIdentity_Mask    = 0,
    kTranslate_Mask   = 0x01,
    kScale_Mask       = 0x02,
    kAffine_Mask      = 0x04,
    kPerspective_Mask = 0x08
};

value	name	说明
0	kIdentity_Mask	单位矩阵
1	kTranslate_Mask	转换矩阵
2	kScale_Mask	缩放矩阵
3	kAffine_Mask	倾斜或旋转矩阵
4	kPerspective_Mask	透视矩阵

---

ScaleToFit

enum ScaleToFit {
    kFill_ScaleToFit,
    kStart_ScaleToFit,
    kCenter_ScaleToFit,
    kEnd_ScaleToFit
};

value	name	说明
0	kFill_ScaleToFit	缩放x和y来填充目标矩形
1	kStart_ScaleToFit	在左和上缩放和对齐
2	kCenter_ScaleToFit	中心缩放和对齐
3	kEnd_ScaleToFit	在右边和底部缩放和对齐

成员函数

---

MakeScale

static Matrix MakeScale(float sx, float sy) {
    Matrix m;
    m.setScale(sx, sy);
    return m;
};

设置矩阵缩放(sx, sy)，返回矩阵：| sx 0 0 | | 0 sy 0 | | 0 0 1 |

参数：

• sx 水平比例因子

• sy 垂直比例因子

返回：缩放矩阵

---

MakeScale

static Matrix MakeScale(float scale) {
    Matrix m;
    m.setScale(scale, scale);
    return m;
};

设置矩阵缩放(scale, scale)，返回矩阵：| scale 0 0 | | 0 scale 0 | | 0 0 1 |

参数：

• scale 水平比例因子

返回：缩放矩阵

---

MakeTrans

static Matrix MakeTrans(float dx, float dy) {
    Matrix m;
    m.setTranslate(dx, dy);
    return m;
};

设置矩阵平移到(dx, dy)，返回矩阵: | 1 0 dx | | 0 1 dy | | 0 0 1 |

参数：

• dx 水平平移

• dy 垂直平移

返回：平移矩阵

---

MakeAll

static Matrix MakeAll(float scaleX, float skewX, float transX, float skewY, float scaleY, float transY, float pers0,
                      float pers1, float pers2) {
    Matrix m;
    m.setAll(scaleX, skewX, transX, skewY, scaleY, transY, pers0, pers1, pers2);
    return m;
};

设置矩阵: | scaleX skewX transX | | skewY scaleY transY | | pers0 pers1 pers2 |

参数：

• scaleX 水平比例因子

• skewX 水平倾斜因子

• transX 水平平移

• skewY 垂直倾斜因子

• scaleY 垂直比例因子

• transY 垂直平移

• pers0 输入x轴透视因子

• pers1 输入y轴透视因子

• pers2 透视比例因子

返回：矩阵

---

getType

TypeMask getType() const {
    if (fTypeMask & kUnknown_Mask) {
            fTypeMask = this->computeTypeMask();
    }
    return (TypeMask)(fTypeMask & 0xF);
};

返回一个位字段，描述矩阵可能进行的转换执行，位域是保守计算的。例如，当设置kPerspective_Mask时，all其他位被设置

参数：无

返回：kIdentity_Mask或kTranslate_Mask、kScale_Mask、kIdentity_Mask的组合kAffine_Mask, kPerspective_Mask

---

isIdentity

bool isIdentity() const {
    return this->getType() == 0;
};

如果矩阵是一致的则返回true，单位矩阵:| 1 0 0 | | 0 1 0 | | 0 0 1 |

参数：无

返回：如果矩阵是一致的则返回true

---

isScaleTranslate

bool isScaleTranslate() const {
    return !(this->getType() & ~(kScale_Mask | kTranslate_Mask));
};

矩阵可以是identity，只包含缩放元素，只包含平移元素，或同时包含二者。矩阵形式: | scale-x 0 translate-x | | 0 scale-y translate-y | | 0 0 1 |

参数：无

返回：如果矩阵是一致的，或者缩放，平移，或者两者兼而有之，则返回true

---

isTranslate

bool isTranslate() const {
    return !(this->getType() & ~(kTranslate_Mask));
};

矩阵形式: | 1 0 translate-x | | 0 1 translate-y | | 0 0 1 |

参数：无

返回：如果矩阵是一致的或者平移的，则返回true

---

rectStaysRect

bool rectStaysRect() const {
    if (fTypeMask & kUnknown_Mask) {
        fTypeMask = this->computeTypeMask();
    }
    return (fTypeMask & kRectStaysRect_Mask) != 0;
};

如果矩阵将一个矩形映射到另一个，则返回true，如果为true，矩阵是一致的，或缩放，或旋转90度的倍数，或者轴上的镜像。在所有情况下，矩阵也可以有平移。矩阵形式可以是： | scale-x 0 translate-x | | 0 scale-y translate-y | | 0 0 1 |

    or

        |    0     rotate-x translate-x |
        | rotate-y    0     translate-y |
        |    0        0          1      | 

对于非零的缩放-x，缩放-y，旋转-x和旋转-y，也称为preservesAxisAlignment()，使用提供更好内联文档的方法

参数：无

返回：如果矩阵将一个矩形映射到另一个，则返回true

---

preservesAxisAlignment

bool preservesAxisAlignment() const {
    return this->rectStaysRect();
};

矩阵将Rect映射到另一个Rect。如果为真，矩阵为恒等，或缩放，或旋转90度，或在轴上反射。在所有情况下，矩阵也可以有翻译。矩阵形式可以是： | scale-x 0 translate-x | | 0 scale-y translate-y | | 0 0 1 |

    or

        |    0     rotate-x translate-x |
        | rotate-y    0     translate-y |
        |    0        0          1      |

对于非零的缩放-x，缩放-y，旋转-x和旋转-y，也称为rectStaysRect()，使用提供更好内联文档的方法。

参数：无

返回：如果矩阵将一个矩形映射到另一个，则返回true

---

operator

float operator[](int index) const {
    MNN_ASSERT((unsigned)index < 9);
    return fMat[index];
};

返回一个矩阵值，如果索引超出范围并且定义了SK_DEBUG，则抛出

参数：

• index kMScaleX, kMSkewX, kMTransX, kMSkewY, kMScaleY, kMTransY, kMPersp0, kMPersp1, kMPersp2其中之一

返回：索引对应的值

---

get

float get(int index) const {
    MNN_ASSERT((unsigned)index < 9);
    return fMat[index];
};

返回一个矩阵值，如果索引超出范围并且定义了SK_DEBUG，则抛出

参数：

• index kMScaleX, kMSkewX, kMTransX, kMSkewY, kMScaleY, kMTransY, kMPersp0, kMPersp1, kMPersp2其中之一

返回：索引对应的值

---

getScaleX

float getScaleX() const {
    return fMat[kMScaleX];
};

返回比例因子 * x轴输入，影响x轴输出。通过mapPoints()方法，缩放点沿着x轴

参数：无

返回：水平缩放因子

---

getScaleY

float getScaleY() const {
    return fMat[kMScaleY];
};

返回比例因子 * y轴输入，影响y轴输出。通过mapPoints()方法，缩放点沿着y轴

参数：无

返回：垂直缩放因子

---

getSkewY

float getSkewY() const {
    return fMat[kMSkewY];
};

返回比例因子 * y轴输入，影响y轴输出。通过mapPoints()方法，沿着y轴倾斜角度。倾斜两个轴可以旋转角度

参数：无

返回：垂直倾斜因子

---

getSkewX

float getSkewX() const {
    return fMat[kMSkewX];
};

返回比例因子 * x轴输入，影响x轴输出。通过mapPoints()方法，沿着x轴倾斜角度。倾斜两个轴可以旋转角度

参数：无

返回：水平倾斜因子

---

getTranslateX

float getTranslateX() const {
    return fMat[kMTransX];
};

返回用于x轴输出的平移。通过mapPoints()方法，沿着x轴移动

参数：无

返回：水平移动因子

---

getTranslateY

float getTranslateY() const {
    return fMat[kMTransY];
};

返回用于y轴输出的平移。通过mapPoints()方法，沿着y轴移动

参数：无

返回：垂直移动因子

---

getPerspX

float getPerspX() const {
    return fMat[kMPersp0];
};

返回x轴缩放输入相对于y轴缩放输入的缩放因子

参数：无

返回：x轴输入的角度因子

---

getPerspY

float getPerspY() const {
    return fMat[kMPersp1];
};

返回y轴缩放输入相对于x轴缩放输入的缩放因子

参数：无

返回：y轴输入的角度因子

---

operator

float& operator[](int index) {
    MNN_ASSERT((unsigned)index < 9);
    this->setTypeMask(kUnknown_Mask);
    return fMat[index];
};

返回可写的矩阵值，如果索引超出范围并且定义了SK_DEBUG，则抛出。清除内部缓存，预计调用者将更改矩阵值。下一次读取矩阵状态可能会重新计算缓存，随后对矩阵值的写入必须在dirtyMatrixTypeCache()之后。

参数：

• index kMScaleX, kMSkewX, kMTransX, kMSkewY, kMScaleY, kMTransY, kMPersp0, kMPersp1, kMPersp2其中之一

返回：索引对应的可写值

---

set

void set(int index, float value) {
    MNN_ASSERT((unsigned)index < 9);
    fMat[index] = value;
    this->setTypeMask(kUnknown_Mask);
};

返回矩阵值，如果索引超出范围并且定义了SK_DEBUG，则抛出。比运营商安全，始终维护内部缓存

参数：

• index kMScaleX, kMSkewX, kMTransX, kMSkewY, kMScaleY, kMTransY, kMPersp0, kMPersp1, kMPersp2其中之一

• value 存储在矩阵中的标量

返回：void

---

setScaleX

void setScaleX(float v) {
    this->set(kMScaleX, v);
};

设置水平比例因子

参数：

• v 存储的水平比例因子

返回：void

---

setScaleY

void setScaleY(float v) {
    this->set(kMScaleY, v);
};

设置垂直比例因子

参数：

• v 存储的垂直比例因子

返回：void

---

setSkewY

void setSkewY(float v) {
    this->set(kMSkewY, v);
};

设置垂直倾斜因子

参数：

• v 存储的垂直倾斜因子

返回：void

---

setSkewX

void setSkewX(float v) {
    this->set(kMSkewX, v);
};

设置水平倾斜因子

参数：

• v 存储的水平倾斜因子

返回：void

---

setTranslateX

void setTranslateX(float v) {
    this->set(kMTransX, v);
};

设置水平平移因子

参数：

• v 存储的水平平移因子

返回：void

---

setTranslateY

void setTranslateY(float v) {
    this->set(kMTransY, v);
};

设置垂直平移因子

参数：

• v 存储的垂直平移因子

返回：void

---

setPerspX

void setPerspX(float v) {
    this->set(kMPersp0, v);
};

设置输入x轴透视因子，它会导致mapXY()改变输入x轴值与输入y轴值成反比

参数：

• v 存储的x轴透视因子

返回：void

---

setPerspY

void setPerspY(float v) {
    this->set(kMPersp1, v);
};

设置输入y轴透视因子，它会导致mapXY()以输入y轴值与输入x轴值成反比的方式改变输入y轴值

参数：

• v 存储的y轴透视因子

返回：void

---

setAll

void setAll(float scaleX, float skewX, float transX, float skewY, float scaleY, float transY, float persp0,
            float persp1, float persp2) {
    fMat[kMScaleX] = scaleX;
    fMat[kMSkewX]  = skewX;
    fMat[kMTransX] = transX;
    fMat[kMSkewY]  = skewY;
    fMat[kMScaleY] = scaleY;
    fMat[kMTransY] = transY;
    fMat[kMPersp0] = persp0;
    fMat[kMPersp1] = persp1;
    fMat[kMPersp2] = persp2;
    this->setTypeMask(kUnknown_Mask);
};

根据参数设置所有值，设置矩阵: | scaleX skewX transX | | skewY scaleY transY | | pers0 pers1 pers2 |

参数：

• scaleX 存储的水平比例因子

• skewX 存储的水平倾斜因子

• transX 存储的水平平移因子

• skewY 存储的垂直倾斜因子

• scaleY 存储的垂直比例因子

• transY 存储的垂直平移因子

• pers0 存储的输入x轴透视因子

• pers1 存储的输入y轴透视因子

• pers2 存储的透视比例因子

返回：矩阵

---

get9

void get9(float buffer[9]) const {
    memcpy(buffer, fMat, 9 * sizeof(float));
};

将矩阵中包含的9个标量值按成员值升序复制到缓冲区:kMScaleX、kMSkewX、kMTransX、kMSkewY、kMScaleY、kMTransY、kMPersp0、kMPersp1、kMPersp2

参数：

• buffer[9] 存储九个标量值

返回：void

---

set9

void set9(const float buffer[9]);

设置矩阵缓冲区中的9个标量值，成员值按升序排列: kMScaleX, kMSkewX, kMTransX, kMSkewY, kMScaleY, kMTransY, kMPersp0, kMPersp1, kMPersp2 设置矩阵： | buffer[0] buffer[1] buffer[2] | | buffer[3] buffer[4] buffer[5] | | buffer[6] buffer[7] buffer[8] | 将来，set9后跟get9可能不会返回相同的值。由于矩阵映射非齐次坐标，缩放所有9个值产生了等效变换，可能会提高精度

参数：

• buffer[9] 九个标量值

返回：void

---

reset

void reset();

设置矩阵单位，这对映射的点没有影响。设置矩阵：| 1 0 0 | | 0 1 0 | | 0 0 1 | 也称为setIdentity()，使用提供更好内联的那个文档

参数：无

返回：void

---

setIdentity

void setIdentity() {
    this->reset();
};

设置矩阵单位，这对映射的点没有影响。设置矩阵：| 1 0 0 | | 0 1 0 | | 0 0 1 | 也称为reset()，使用提供更好内联的那个文档

参数：无

返回：void

---

setTranslate

void setTranslate(float dx, float dy);

设置矩阵平移到(dx, dy)

参数：

• dx 水平平移

• dy 垂直平移

返回：void

---

setScale

void setScale(float sx, float sy, float px, float py);

设置矩阵缩放sx和sy，大约一个枢轴点(px, py)，当映射到矩阵时，枢轴点是不变的

参数：

• sx 水平缩放因子

• sy 垂直缩放因子

• px x轴

• py y轴

返回：void

---

setScale

void setScale(float sx, float sy);

设置矩阵在(0,0)的枢轴点处按sx和sy缩放

参数：

• sx 水平缩放因子

• sy 垂直缩放因子

返回：void

---

setRotate

void setRotate(float degrees, float px, float py);

设置矩阵以轴点(px, py)旋转角度，当映射到矩阵时，枢轴点是不变的，正度顺时针旋转

参数：

• degrees 水平坐标轴与垂直坐标轴的夹角

• sx 水平缩放因子

• sy 垂直缩放因子

返回：void

---

setSinCos

void setSinCos(float sinValue, float cosValue, float px, float py);

设置矩阵旋转sinValue和cosValue，旋转一个轴心点(px, py)。当映射到矩阵时，轴点是不变的，向量(sinValue, cosValue)描述相对于(0,1)的旋转角度，向量长度指定缩放

参数：

• sinValue 旋转向量x轴部分

• cosValue 旋转向量y轴部分

• sx 水平缩放因子

• sy 垂直缩放因子

返回：void

---

setSinCos

void setSinCos(float sinValue, float cosValue);

设置矩阵的sinValue和cosValue旋转，大约在(0,0)的轴点。向量(sinValue, cosValue)描述相对于(0,1)的旋转角度，向量长度指定缩放

参数：

• sinValue 旋转向量x轴部分

• cosValue 旋转向量y轴部分

返回：void

---

setSkew

void setSkew(float kx, float ky, float px, float py);

设置矩阵在kx和ky上的倾斜，关于一个轴点(px, py)，当映射到矩阵时，轴点是不变的

参数：

• kx 水平倾斜因子

• ky 垂直倾斜因子

• px x轴

• py y轴

返回：void

---

setConcat

void setConcat(const Matrix& a, const Matrix& b);

将矩阵设为矩阵a乘以矩阵b，a或b都可以是这个 假定： | A B C | | J K L | a = | D E F |, b = | M N O | | G H I | | P Q R | 设置矩阵： | A B C | | J K L | | AJ+BM+CP AK+BN+CQ AL+BO+CR | a * b = | D E F | * | M N O | = | DJ+EM+FP DK+EN+FQ DL+EO+FR | | G H I | | P Q R | | GJ+HM+IP GK+HN+IQ GL+HO+IR |

参数：

• a 乘法表达式的左边矩阵

• b 乘法表达式的右边矩阵

返回：void

---

preTranslate

void preTranslate(float dx, float dy);

设置矩阵到矩阵乘以由平移(dx, dy)构造的矩阵，这可以被认为是在应用矩阵之前移动要映射的点 假定： | A B C | | 1 0 dx | Matrix = | D E F |, T(dx, dy) = | 0 1 dy | | G H I | | 0 0 1 | 设置矩阵： | A B C | | 1 0 dx | | A B Adx+Bdy+C | Matrix * T(dx, dy) = | D E F | | 0 1 dy | = | D E Ddx+Edy+F | | G H I | | 0 0 1 | | G H Gdx+Hdy+I |

参数：

• dx 应用矩阵前在x轴平移

• dy 应用矩阵前在y轴平移

返回：void

---

preScale

void preScale(float sx, float sy, float px, float py);

在应用矩阵之前缩放一个轴点 假定： | A B C | | 1 0 dx | Matrix = | D E F |, T(dx, dy) = | 0 1 dy | | G H I | | 0 0 1 | 目标：

        dx = px - sx * px
        dy = py - sy * py

设置矩阵： | A B C | | 1 0 dx | | A B Adx+Bdy+C | Matrix * T(dx, dy) = | D E F | | 0 1 dy | = | D E Ddx+Edy+F | | G H I | | 0 0 1 | | G H Gdx+Hdy+I |

参数：

• sx 水平比例因子

• sy 垂直比例因子

• px x轴

• py y轴

返回：void

---

preScale

void preScale(float sx, float sy);

在应用矩阵之前缩放原点 假定： | A B C | | sx 0 0 | Matrix = | D E F |, S(sx, sy) = | 0 sy 0 | | G H I | | 0 0 1 | 目标： c = cos(degrees) s = sin(degrees) dx = s * py + (1 - c) * px dy = -s * px + (1 - c) * py

设置矩阵： | A B C | | c -s dx | | Ac+Bs -As+Bc Adx+Bdy+C | Matrix * R(degrees, px, py) = | D E F | | s c dy | = | Dc+Es -Ds+Ec Ddx+Edy+F | | G H I | | 0 0 1 | | Gc+Hs -Gs+Hc Gdx+Hdy+I | 参数：

• sx 水平比例因子

• sy 垂直比例因子

返回：void

---

preRotate

void preRotate(float degrees, float px, float py);

在应用矩阵之前绕一个轴点旋转，顺时针旋转为正 假定： | A B C | | c -s dx | Matrix = | D E F |, R(degrees, px, py) = | s c dy | | G H I | | 0 0 1 | 目标： c = cos(degrees) s = sin(degrees) dx = s * py + (1 - c) * px dy = -s * px + (1 - c) * py 设置矩阵：

                                      | A B C | | c -s dx |   | Ac+Bs -As+Bc A*dx+B*dy+C |
        Matrix * R(degrees, px, py) = | D E F | | s  c dy | = | Dc+Es -Ds+Ec D*dx+E*dy+F |
                                      | G H I | | 0  0  1 |   | Gc+Hs -Gs+Hc G*dx+H*dy+I |

参数：

• degrees 坐标轴与垂直坐标轴的夹角

• px x轴

• py y轴

返回：void

---

preRotate

void preRotate(float degrees);

应用矩阵之前绕原点旋转，顺时针旋转为正 假定： | A B C | | c -s dx | Matrix = | D E F |, R(degrees, px, py) = | s c dy | | G H I | | 0 0 1 | 目标： c = cos(degrees) s = sin(degrees) 设置矩阵： | A B C | | c -s 0 | | Ac+Bs -As+Bc C | Matrix * R(degrees, px, py) = | D E F | | s c 0 | = | Dc+Es -Ds+Ec F | | G H I | | 0 0 1 | | Gc+Hs -Gs+Hc I |

参数：

• degrees 坐标轴与垂直坐标轴的夹角

返回：void

---

preSkew

void preSkew(float kx, float ky, float px, float py);

应用矩阵之前绕一个轴点倾斜 假定： | A B C | | 1 kx dx | Matrix = | D E F |, K(kx, ky, px, py) = | ky 1 dy | | G H I | | 0 0 1 | 目标： dx = -kx * py dy = -ky * px 设置矩阵： | A B C | | 1 kx dx | | A+Bky Akx+B Adx+Bdy+C | Matrix * K(kx, ky, px, py) = | D E F | | ky 1 dy | = | D+Eky Dkx+E Ddx+Edy+F | | G H I | | 0 0 1 | | G+Hky Gkx+H Gdx+Hdy+I |

参数：

• kx 水平倾斜因子

• ky 垂直倾斜因子

• px x轴

• py y轴

返回：void

---

preSkew

void preSkew(float kx, float ky);

应用矩阵之前绕原点倾斜 假定： | A B C | | 1 kx 0 | Matrix = | D E F |, K(kx, ky) = | ky 1 0 | | G H I | | 0 0 1 | 设置矩阵： | A B C | | 1 kx 0 | | A+Bky Akx+B C | Matrix * K(kx, ky) = | D E F | | ky 1 0 | = | D+Eky Dkx+E F | | G H I | | 0 0 1 | | G+Hky Gkx+H I |

参数：

• kx 水平倾斜因子

• ky 垂直倾斜因子

返回：void

---

preConcat

void preConcat(const Matrix& other);

在应用矩阵之前的映射 假定： | A B C | | J K L | Matrix = | D E F |, other = | M N O | | G H I | | P Q R | 设置矩阵： | A B C | | J K L | | AJ+BM+CP AK+BN+CQ AL+BO+CR | Matrix * other = | D E F | * | M N O | = | DJ+EM+FP DK+EN+FQ DL+EO+FR | | G H I | | P Q R | | GJ+HM+IP GK+HN+IQ GL+HO+IR |

参数：

• other 乘法表达式的右边矩阵

返回：void

---

postTranslate

void postTranslate(float dx, float dy);

应用矩阵后移动被映射的点 假定： | J K L | | 1 0 dx | Matrix = | M N O |, T(dx, dy) = | 0 1 dy | | P Q R | | 0 0 1 | 设置矩阵： | 1 0 dx | | J K L | | J+dxP K+dxQ L+dxR | T(dx, dy) * Matrix = | 0 1 dy | | M N O | = | M+dyP N+dyQ O+dyR | | 0 0 1 | | P Q R | | P Q R |

参数：

• dx 应用矩阵后的x轴平移

• dy 应用矩阵后的y轴平移

返回：void

---

postScale

void postScale(float sx, float sy, float px, float py);

应用矩阵后缩放一个轴点 假定： | J K L | | sx 0 dx | Matrix = | M N O |, S(sx, sy, px, py) = | 0 sy dy | | P Q R | | 0 0 1 | 目标： dx = px - sx * px dy = py - sy * py 设置矩阵： | sx 0 dx | | J K L | | sxJ+dxP sxK+dxQ sxL+dx+R | S(sx, sy, px, py) * Matrix = | 0 sy dy | | M N O | = | syM+dyP syN+dyQ syO+dy*R | | 0 0 1 | | P Q R | | P Q R | 参数：

• sx 水平比例因子

• sy 垂直比例因子

• px x轴

• py y轴

返回：void

---

postScale

void postScale(float sx, float sy);

应用矩阵之后关于原点的缩放 假定： | J K L | | sx 0 0 | Matrix = | M N O |, S(sx, sy) = | 0 sy 0 | | P Q R | | 0 0 1 | 设置矩阵： | sx 0 0 | | J K L | | sxJ sxK sxL | S(sx, sy) * Matrix = | 0 sy 0 | | M N O | = | syM syN syO | | 0 0 1 | | P Q R | | P Q R | 参数：

• sx 水平比例因子

• sy 垂直比例因子

返回：void

---

postIDiv

bool postIDiv(int divx, int divy);

应用矩阵之后按照(1/divx, 1/divy)比例缩放一个枢轴点 假定： | J K L | | sx 0 0 | Matrix = | M N O |, I(divx, divy) = | 0 sy 0 | | P Q R | | 0 0 1 | 目标： sx = 1 / divx sy = 1 / divy 设置矩阵： | sx 0 0 | | J K L | | sxJ sxK sxL | I(divx, divy) * Matrix = | 0 sy 0 | | M N O | = | syM syN syO | | 0 0 1 | | P Q R | | P Q R | 参数：

• divx x逆比例的整数除数

• divy y逆比例的整数除数

返回：缩放成功返回true

---

postRotate

void postRotate(float degrees, float px, float py);

应用矩阵后绕一个枢轴点旋转 假定： | J K L | | c -s dx | Matrix = | M N O |, R(degrees, px, py) = | s c dy | | P Q R | | 0 0 1 | 目标： c = cos(degrees) s = sin(degrees) dx = s * py + (1 - c) * px dy = -s * px + (1 - c) * py 设置矩阵： |c -s dx| |J K L| |cJ-sM+dxP cK-sN+dxQ cL-sO+dx+R| R(degrees, px, py) * Matrix = |s c dy| |M N O| = |sJ+cM+dyP sK+cN+dyQ sL+cO+dy*R| |0 0 1| |P Q R| | P Q R| 参数：

• degrees 坐标轴与垂直坐标轴的夹角

• px x轴

• py y轴

返回：void

---

postRotate

void postRotate(float degrees);

应用矩阵后绕原点旋转 假定： | J K L | | c -s 0 | Matrix = | M N O |, R(degrees, px, py) = | s c 0 | | P Q R | | 0 0 1 | 目标： c = cos(degrees) s = sin(degrees) 设置矩阵： | c -s dx | | J K L | | cJ-sM cK-sN cL-sO | R(degrees, px, py) * Matrix = | s c dy | | M N O | = | sJ+cM sK+cN sL+cO | | 0 0 1 | | P Q R | | P Q R | 参数：

• degrees 坐标轴与垂直坐标轴的夹角

返回：void

---

postSkew

void postSkew(float kx, float ky, float px, float py);

应用矩阵后绕一个枢轴点倾斜 假定： | J K L | | 1 kx dx | Matrix = | M N O |, K(kx, ky, px, py) = | ky 1 dy | | P Q R | | 0 0 1 | 目标： dx = -kx * py dy = -ky * px 设置矩阵： | 1 kx dx| |J K L| |J+kxM+dxP K+kxN+dxQ L+kxO+dx+R| K(kx, ky, px, py) * Matrix = |ky 1 dy| |M N O| = |kyJ+M+dyP kyK+N+dyQ kyL+O+dy*R| | 0 0 1| |P Q R| | P Q R| 参数：

• kx 水平倾斜因子

• ky 垂直倾斜因子

• px x轴

• py y轴

返回：void

---

postSkew

void postSkew(float kx, float ky);

应用矩阵后绕一个枢轴点倾斜 假定： | J K L | | 1 kx 0 | Matrix = | M N O |, K(kx, ky) = | ky 1 0 | | P Q R | | 0 0 1 | 设置矩阵： | 1 kx 0 | | J K L | | J+kxM K+kxN L+kxO | K(kx, ky) * Matrix = | ky 1 0 | | M N O | = | kyJ+M kyK+N kyL+O | | 0 0 1 | | P Q R | | P Q R | 参数：

• kx 水平倾斜因子

• ky 垂直倾斜因子

返回：void

---

postConcat

void postConcat(const Matrix& other);

设置矩阵到矩阵其他乘以矩阵，这可以被认为是映射后，其他应用矩阵 假定： | J K L | | A B C | Matrix = | M N O |, other = | D E F | | P Q R | | G H I | 设置矩阵： | A B C | | J K L | | AJ+BM+CP AK+BN+CQ AL+BO+CR | other * Matrix = | D E F | * | M N O | = | DJ+EM+FP DK+EN+FQ DL+EO+FR | | G H I | | P Q R | | GJ+HM+IP GK+HN+IQ GL+HO+IR | 参数：

• other 乘法表达式的左边矩阵

返回：void

---

setRectToRect

bool setRectToRect(const Rect& src, const Rect& dst, ScaleToFit stf);

设置矩阵缩放并将src Rect转换为dst，recf选择映射是否完全填充dst或保留长宽比，以及如何在dst内对齐src。如果src为空则返回false，并设置矩阵为identity。如果dst为空则返回true 设置矩阵：| 0 0 0 | | 0 0 0 | | 0 0 1 | 参数：

• src 要映射的rect

• dst 要映射到的rect

• stf kFill_ScaleToFit, kStart_ScaleToFit,kCenter_ScaleToFit, kEnd_ScaleToFit其中之一

返回：如果矩阵可以表示Rect映射，则为true

---

MakeRectToRect

static Matrix MakeRectToRect(const Rect& src, const Rect& dst, ScaleToFit stf) {
    Matrix m;
    m.setRectToRect(src, dst, stf);
    return m;
};

返回矩阵设置为缩放并将src Rect转换为dst，recf选择映射是否完全填充dst或保留长宽比，以及如何在dst内对齐src。如果src为空，则返回标识矩阵。如果dst为空，返回设置矩阵：| 0 0 0 | | 0 0 0 | | 0 0 1 | 参数：

• src 要映射的rect

• dst 要映射到的rect

• stf kFill_ScaleToFit, kStart_ScaleToFit,kCenter_ScaleToFit, kEnd_ScaleToFit其中之一

返回：将src映射到dst的矩阵

---

setPolyToPoly

bool setPolyToPoly(const Point src[], const Point dst[], int count);

设置“矩阵”将src映射到dst，Count必须为0或更大，4或更小。 如果count为零，设置Matrix为identity并返回true。 如果count为1，设置Matrix转换并返回true。 如果count是两个或更多，设置矩阵映射点，如果可能;返回false 如果矩阵不能被构造。如果计数是4，矩阵可能包括透视。

参数：

• src[] 要映射的rect

• dst[] 要映射到的rect

• count 在scr和dst中点的数量

返回：如果矩阵构造成功，返回true

---

invert

bool invert(Matrix* inverse) const {
    if (this->isIdentity()) {
        if (inverse) {
            inverse->reset();
        }
        return true;
    }
    return this->invertNonIdentity(inverse);
};

矩阵反转，几何上，如果矩阵从源映射到目标，则逆矩阵从目标映射到源。如果矩阵不能被反转，逆矩阵不变

参数：

• inverse 要被反转的矩阵，可能是nullptr

返回：矩阵反转成功，返回true

---

SetAffineIdentity

static void SetAffineIdentity(float affine[6]);

在主序列中用标识值填充仿射 设置仿射： | 1 0 0 | | 0 1 0 | OpenGL和XPS在主序列中仿射3x2矩阵

参数：

• affine 3x2仿射矩阵

返回：void

---

asAffine

bool asAffine(float affine[6]) const;

在主序列中填充仿射 设置仿射： | scale-x skew-x translate-x | | skew-y scale-y translate-y | 如果矩阵包含透视图，则返回false并保持仿射不变

参数：

• affine 3x2仿射矩阵，可能是nullptr

返回：如果矩阵不包含透视图，则返回true

---

setAffine

void setAffine(const float affine[6]);

将矩阵设置为仿射值，按主序列传递，给定仿射，列|行 例如： | scale-x skew-x translate-x | | skew-y scale-y translate-y |

矩阵是集合，行|列 例如： | scale-x skew-x translate-x | | skew-y scale-y translate-y | | 0 0 1 |

参数：

• affine 3 x2仿射矩阵

返回：void

---

mapPoints

void mapPoints(Point dst[], const Point src[], int count) const {
    MNN_ASSERT((dst && src && count > 0) || 0 == count);
    MNN_ASSERT(src == dst || &dst[count] <= &src[0] || &src[count] <= &dst[0]);
    this->getMapPtsProc()(*this, dst, src, count);
};

映射指定长度计数的点数组，通过将每个点乘以矩阵来映射点 假定： | A B C | | x | Matrix = | D E F |, pt = | y | | G H I | | 1 | 目标： for (i = 0; i < count; ++i) { x = pts[i].fX y = pts[i].fY } 每一个点的计算结果为： |A B C| |x| Ax+By+C Dx+Ey+F Matrix * pt = |D E F| |y| = |Ax+By+C Dx+Ey+F Gx+Hy+I| = ——- , ——- |G H I| |1| Gx+Hy+I Gx+Hy+I SRC和DST可能指向相同的存储空间

参数：

• dst 映射点存储空间

• src 变换点

• count 变换点的个数

返回：void

---

mapPoints

void mapPoints(Point pts[], int count) const {
    this->mapPoints(pts, pts, count);
};

映射指定长度计数的点数组，通过将每个点乘以矩阵来映射点 假定： | A B C | | x | Matrix = | D E F |, pt = | y | | G H I | | 1 | 目标： for (i = 0; i < count; ++i) { x = pts[i].fX y = pts[i].fY } 每一个点的计算结果为： |A B C| |x| Ax+By+C Dx+Ey+F Matrix * pt = |D E F| |y| = |Ax+By+C Dx+Ey+F Gx+Hy+I| = ——- , ——- |G H I| |1| Gx+Hy+I Gx+Hy+I SRC和DST可能指向相同的存储空间

参数：

• pts 映射点存储空间

• count 变换点的个数

返回：void

---

mapXY

void mapXY(float x, float y, Point* result) const {
    this->getMapXYProc()(*this, x, y, result);
};

点(x, y)的映射结果，点通过乘以矩阵来映射 假定： | A B C | | x | Matrix = | D E F |, pt = | y | | G H I | | 1 | 计算结果为： |A B C| |x| Ax+By+C Dx+Ey+F Matrix * pt = |D E F| |y| = |Ax+By+C Dx+Ey+F Gx+Hy+I| = ——- , ——- |G H I| |1| Gx+Hy+I Gx+Hy+I

参数：

• x 要映射的点的x轴值

• y 要映射的点的y轴值

• result 映射点的存储

返回：void

---

mapXY

Point mapXY(float x, float y) const {
    Point result;
    this->getMapXYProc()(*this, x, y, &result);
    return result;
};

点(x, y)的映射结果，点通过乘以矩阵来映射 假定： | A B C | | x | Matrix = | D E F |, pt = | y | | G H I | | 1 | 计算结果为： |A B C| |x| Ax+By+C Dx+Ey+F Matrix * pt = |D E F| |y| = |Ax+By+C Dx+Ey+F Gx+Hy+I| = ——- , ——- |G H I| |1| Gx+Hy+I Gx+Hy+I

参数：

• x 要映射的点的x轴值

• y 要映射的点的y轴值

返回：映射点

---

mapRect

bool mapRect(Rect* dst, const Rect& src) const;

将dst设置为矩阵映射的src角的边界，如果映射的角是dst角则返回true。返回值与调用rectStaysRect()方法相同

参数：

• dst 存储的映射点的边界

• src 要绘制的rect

返回：如果DST等价于映射的SRC，则为True

---

mapRect

bool mapRect(Rect* rect) const {
    return this->mapRect(rect, *rect);
};

将rect设置为矩阵映射的矩形角的边界，如果映射的角是计算出来的矩形角，则返回true，返回值与调用rectStaysRect()相同

参数：

• rect 要映射的rect，并存储映射角的边界

返回：如果结果等价于映射的SRC，则为True

---

mapRect

Rect mapRect(const Rect& src) const {
    Rect dst;
    (void)this->mapRect(&dst, src);
    return dst;
};

返回由矩阵映射的src角的边界

参数：

• src 要绘制的矩形

返回：映射的边界

---

mapRectScaleTranslate

void mapRectScaleTranslate(Rect* dst, const Rect& src) const;

将dst设置为矩阵映射的src角的边界，如果矩阵包含了缩放或转换以外的元素:如果SK_DEBUG被定义了则生效，否则结果为undefined

参数：

• dst 存储映射点的边界

• src 要绘制的Rect

返回：void

---

cheapEqualTo

bool cheapEqualTo(const Matrix& m) const {
    return 0 == memcmp(fMat, m.fMat, sizeof(fMat));
};

如果矩阵等于m，则返回true；当zero值的符号不同时返回false；当一个矩阵为正zero另一个矩阵为负zero时，即使两个矩阵都包含NaN，也返回true。NaN从不等于任何值，包括它自己。为了提高性能，如果NaN值的位模式相等，则将其视为相等的位模式。

参数：

• m 被比较的矩阵

返回：如果m和矩阵由相同的位模式表示，则为true

---

operator==

friend MNN_PUBLIC bool operator==(const Matrix& a, const Matrix& b);

比较a和b，如果a和b在数值上相等，返回true。即使zero值的符号不同，也返回true。如果其中一个矩阵包含NaN，则返回false，即使另一个矩阵也包含NaN

参数：

• a 被比较的矩阵a

• b 被比较的矩阵b

返回：当矩阵a和矩阵b在数值上相等时为true

---

operator!=

friend MNN_PUBLIC bool operator!=(const Matrix& a, const Matrix& b) {
    return !(a == b);
};

比较a和b，如果a和b在数值上不相等，则返回true。即使zero值的符号不同，也返回false。如果其中一个矩阵包含NaN，则返回true，即使另一个矩阵也包含NaN

参数：

• a 被比较的矩阵a

• b 被比较的矩阵b

返回：如果矩阵a和矩阵b在数值上不相等，则为true

---

dump

void dump() const;

将矩阵的文本表示形式写入标准输出，浮点值的写入精度有限，可能无法重建原始矩阵的输出

参数：无

返回：void

---

getMinScale

float getMinScale() const;

通过分解缩放和倾斜元素，返回矩阵的最小缩放因子。如果比例因子溢出或矩阵包含透视图，则返回-1

参数：无

返回：最小缩放因子

---

getMaxScale

float getMaxScale() const;

通过分解缩放和倾斜元素，返回矩阵的最大缩放因子。如果比例因子溢出或矩阵包含透视图，则返回-1

参数：无

返回：最大缩放因子

---

getMinMaxScales

bool getMinMaxScales(float scaleFactors[2]) const;

将scaleFactors[0]设置为最小缩放因子，将scaleFactors[1]设置为最大缩放因子。缩放因子是通过分解矩阵缩放和倾斜元素来计算的。如果找到scaleFactors则返回true，否则，返回false，并将scaleFactors设置为未定义的值

参数：

• scaleFactors 最小和最大的缩放因子

返回：如果缩放因子计算正确，则返回true

---

I

static const Matrix& I();

返回对单位矩阵常量的引用，返回矩阵被设置为： | 1 0 0 | | 0 1 0 | | 0 0 1 |

参数：无

返回：单位矩阵常量

---

InvalidMatrix

static const Matrix& InvalidMatrix();

返回指向一个值无效的常量矩阵的引用，返回矩阵被设置为： | SK_ScalarMax SK_ScalarMax SK_ScalarMax | | SK_ScalarMax SK_ScalarMax SK_ScalarMax | | SK_ScalarMax SK_ScalarMax SK_ScalarMax |

参数：无

返回：无效的常量矩阵

---

Concat

static Matrix Concat(const Matrix& a, const Matrix& b) {
    Matrix result;
    result.setConcat(a, b);
    return result;
};

返回矩阵a乘以矩阵b 假定： | A B C | | J K L | a = | D E F |, b = | M N O | | G H I | | P Q R | 设置矩阵为： | A B C | | J K L | | AJ+BM+CP AK+BN+CQ AL+BO+CR | a * b = | D E F | * | M N O | = | DJ+EM+FP DK+EN+FQ DL+EO+FR | | G H I | | P Q R | | GJ+HM+IP GK+HN+IQ GL+HO+IR |

参数：

• a 乘法表达式的左边矩阵

• b 乘法表达式的右边矩阵

返回：无效的常量矩阵

---

dirtyMatrixTypeCache

void dirtyMatrixTypeCache() {
    this->setTypeMask(kUnknown_Mask);
};

将内部缓存设置为未知状态，用于在对操作符[](int index)返回的矩阵元素引用进行重复修改后强制更新

参数：无

返回：void

---

setScaleTranslate

void setScaleTranslate(float sx, float sy, float tx, float ty) {
    fMat[kMScaleX] = sx;
    fMat[kMSkewX]  = 0;
    fMat[kMTransX] = tx;

    fMat[kMSkewY]  = 0;
    fMat[kMScaleY] = sy;
    fMat[kMTransY] = ty;

    fMat[kMPersp0] = 0;
    fMat[kMPersp1] = 0;
    fMat[kMPersp2] = 1;

    unsigned mask = 0;
    if (sx != 1 || sy != 1) {
        mask |= kScale_Mask;
    }
    if (tx || ty) {
        mask |= kTranslate_Mask;
    }
    this->setTypeMask(mask | kRectStaysRect_Mask);
};

使用缩放和转换元素初始化矩阵 | sx 0 tx | | 0 sy ty | | 0 0 1 |

参数：

• sx 水平缩放因子

• sy 垂直缩放因子

• tx 水平平移因子

• ty 垂直平移因子

返回：void