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
要映射的rectdst
要映射到的rectstf
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
要映射的rectdst
要映射到的rectstf
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[]
要映射的rectdst[]
要映射到的rectcount
在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
被比较的矩阵ab
被比较的矩阵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
被比较的矩阵ab
被比较的矩阵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