root
/
MNN
mirror of https://github.com/alibaba/MNN.git
1
0
Fork 0
Code Issues Actions 1 Packages Projects Releases Wiki Activity
MNN/docs/cpp/Matrix.md

1608 lines
41 KiB
Markdown
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

# Matrix
```cpp
class Matrix
```
## 枚举类
### TypeMask
```cpp
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
```cpp
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
```cpp
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
```cpp
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
```cpp
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
```cpp
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
```cpp
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
```cpp
bool isIdentity() const {
return this->getType() == 0;
};
```
如果矩阵是一致的则返回true，单位矩阵:| 1 0 0 |
| 0 1 0 |
| 0 0 1 |
参数：无
返回：如果矩阵是一致的则返回true
---
### isScaleTranslate
```cpp
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
```cpp
bool isTranslate() const {
return !(this->getType() & ~(kTranslate_Mask));
};
```
矩阵形式: | 1 0 translate-x |
| 0 1 translate-y |
| 0 0 1 |
参数：无
返回：如果矩阵是一致的或者平移的，则返回true
---
### rectStaysRect
```cpp
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
```cpp
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
```cpp
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
```cpp
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
```cpp
float getScaleX() const {
return fMat[kMScaleX];
};
```
返回比例因子 * x轴输入，影响x轴输出。通过mapPoints()方法，缩放点沿着x轴
参数：无
返回：水平缩放因子
---
### getScaleY
```cpp
float getScaleY() const {
return fMat[kMScaleY];
};
```
返回比例因子 * y轴输入，影响y轴输出。通过mapPoints()方法，缩放点沿着y轴
参数：无
返回：垂直缩放因子
---
### getSkewY
```cpp
float getSkewY() const {
return fMat[kMSkewY];
};
```
返回比例因子 * y轴输入，影响y轴输出。通过mapPoints()方法，沿着y轴倾斜角度。倾斜两个轴可以旋转角度
参数：无
返回：垂直倾斜因子
---
### getSkewX
```cpp
float getSkewX() const {
return fMat[kMSkewX];
};
```
返回比例因子 * x轴输入，影响x轴输出。通过mapPoints()方法，沿着x轴倾斜角度。倾斜两个轴可以旋转角度
参数：无
返回：水平倾斜因子
---
### getTranslateX
```cpp
float getTranslateX() const {
return fMat[kMTransX];
};
```
返回用于x轴输出的平移。通过mapPoints()方法，沿着x轴移动
参数：无
返回：水平移动因子
---
### getTranslateY
```cpp
float getTranslateY() const {
return fMat[kMTransY];
};
```
返回用于y轴输出的平移。通过mapPoints()方法，沿着y轴移动
参数：无
返回：垂直移动因子
---
### getPerspX
```cpp
float getPerspX() const {
return fMat[kMPersp0];
};
```
返回x轴缩放输入相对于y轴缩放输入的缩放因子
参数：无
返回：x轴输入的角度因子
---
### getPerspY
```cpp
float getPerspY() const {
return fMat[kMPersp1];
};
```
返回y轴缩放输入相对于x轴缩放输入的缩放因子
参数：无
返回：y轴输入的角度因子
---
### operator
```cpp
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
```cpp
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
```cpp
void setScaleX(float v) {
this->set(kMScaleX, v);
};
```
设置水平比例因子
参数：
- `v` 存储的水平比例因子
返回：`void`
---
### setScaleY
```cpp
void setScaleY(float v) {
this->set(kMScaleY, v);
};
```
设置垂直比例因子
参数：
- `v` 存储的垂直比例因子
返回：`void`
---
### setSkewY
```cpp
void setSkewY(float v) {
this->set(kMSkewY, v);
};
```
设置垂直倾斜因子
参数：
- `v` 存储的垂直倾斜因子
返回：`void`
---
### setSkewX
```cpp
void setSkewX(float v) {
this->set(kMSkewX, v);
};
```
设置水平倾斜因子
参数：
- `v` 存储的水平倾斜因子
返回：`void`
---
### setTranslateX
```cpp
void setTranslateX(float v) {
this->set(kMTransX, v);
};
```
设置水平平移因子
参数：
- `v` 存储的水平平移因子
返回：`void`
---
### setTranslateY
```cpp
void setTranslateY(float v) {
this->set(kMTransY, v);
};
```
设置垂直平移因子
参数：
- `v` 存储的垂直平移因子
返回：`void`
---
### setPerspX
```cpp
void setPerspX(float v) {
this->set(kMPersp0, v);
};
```
设置输入x轴透视因子，它会导致mapXY()改变输入x轴值与输入y轴值成反比
参数：
- `v` 存储的x轴透视因子
返回：`void`
---
### setPerspY
```cpp
void setPerspY(float v) {
this->set(kMPersp1, v);
};
```
设置输入y轴透视因子，它会导致mapXY()以输入y轴值与输入x轴值成反比的方式改变输入y轴值
参数：
- `v` 存储的y轴透视因子
返回：`void`
---
### setAll
```cpp
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
```cpp
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
```cpp
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
```cpp
void reset();
```
设置矩阵单位，这对映射的点没有影响。设置矩阵：| 1 0 0 |
| 0 1 0 |
| 0 0 1 |
也称为setIdentity()，使用提供更好内联的那个文档
参数：无
返回：`void`
---
### setIdentity
```cpp
void setIdentity() {
this->reset();
};
```
设置矩阵单位，这对映射的点没有影响。设置矩阵：| 1 0 0 |
| 0 1 0 |
| 0 0 1 |
也称为reset()，使用提供更好内联的那个文档
参数：无
返回：`void`
---
### setTranslate
```cpp
void setTranslate(float dx, float dy);
```
设置矩阵平移到(dx, dy)
参数：
- `dx` 水平平移
- `dy` 垂直平移
返回：`void`
---
### setScale
```cpp
void setScale(float sx, float sy, float px, float py);
```
设置矩阵缩放sx和sy，大约一个枢轴点(px, py)，当映射到矩阵时，枢轴点是不变的
参数：
- `sx` 水平缩放因子
- `sy` 垂直缩放因子
- `px` x轴
- `py` y轴
返回：`void`
---
### setScale
```cpp
void setScale(float sx, float sy);
```
设置矩阵在(0,0)的枢轴点处按sx和sy缩放
参数：
- `sx` 水平缩放因子
- `sy` 垂直缩放因子
返回：`void`
---
### setRotate
```cpp
void setRotate(float degrees, float px, float py);
```
设置矩阵以轴点(px, py)旋转角度，当映射到矩阵时，枢轴点是不变的，正度顺时针旋转
参数：
- `degrees` 水平坐标轴与垂直坐标轴的夹角
- `sx` 水平缩放因子
- `sy` 垂直缩放因子
返回：`void`
---
### setSinCos
```cpp
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
```cpp
void setSinCos(float sinValue, float cosValue);
```
设置矩阵的sinValue和cosValue旋转，大约在(0,0)的轴点。向量(sinValue, cosValue)描述相对于(0,1)的旋转角度，向量长度指定缩放
参数：
- `sinValue` 旋转向量x轴部分
- `cosValue` 旋转向量y轴部分
返回：`void`
---
### setSkew
```cpp
void setSkew(float kx, float ky, float px, float py);
```
设置矩阵在kx和ky上的倾斜，关于一个轴点(px, py)，当映射到矩阵时，轴点是不变的
参数：
- `kx` 水平倾斜因子
- `ky` 垂直倾斜因子
- `px` x轴
- `py` y轴
返回：`void`
---
### setConcat
```cpp
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
```cpp
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 A*dx+B*dy+C |
Matrix * T(dx, dy) = | D E F | | 0 1 dy | = | D E D*dx+E*dy+F |
| G H I | | 0 0 1 | | G H G*dx+H*dy+I |
参数：
- `dx` 应用矩阵前在x轴平移
- `dy` 应用矩阵前在y轴平移
返回：`void`
---
### preScale
```cpp
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 A*dx+B*dy+C |
Matrix * T(dx, dy) = | D E F | | 0 1 dy | = | D E D*dx+E*dy+F |
| G H I | | 0 0 1 | | G H G*dx+H*dy+I |
参数：
- `sx` 水平比例因子
- `sy` 垂直比例因子
- `px` x轴
- `py` y轴
返回：`void`
---
### preScale
```cpp
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 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 |
参数：
- `sx` 水平比例因子
- `sy` 垂直比例因子
返回：`void`
---
### preRotate
```cpp
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
```cpp
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
```cpp
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+B*ky A*kx+B A*dx+B*dy+C |
Matrix * K(kx, ky, px, py) = | D E F | | ky 1 dy | = | D+E*ky D*kx+E D*dx+E*dy+F |
| G H I | | 0 0 1 | | G+H*ky G*kx+H G*dx+H*dy+I |
参数：
- `kx` 水平倾斜因子
- `ky` 垂直倾斜因子
- `px` x轴
- `py` y轴
返回：`void`
---
### preSkew
```cpp
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+B*ky A*kx+B C |
Matrix * K(kx, ky) = | D E F | | ky 1 0 | = | D+E*ky D*kx+E F |
| G H I | | 0 0 1 | | G+H*ky G*kx+H I |
参数：
- `kx` 水平倾斜因子
- `ky` 垂直倾斜因子
返回：`void`
---
### preConcat
```cpp
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
```cpp
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+dx*P K+dx*Q L+dx*R |
T(dx, dy) * Matrix = | 0 1 dy | | M N O | = | M+dy*P N+dy*Q O+dy*R |
| 0 0 1 | | P Q R | | P Q R |
参数：
- `dx` 应用矩阵后的x轴平移
- `dy` 应用矩阵后的y轴平移
返回：`void`
---
### postScale
```cpp
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 | | sx*J+dx*P sx*K+dx*Q sx*L+dx+R |
S(sx, sy, px, py) * Matrix = | 0 sy dy | | M N O | = | sy*M+dy*P sy*N+dy*Q sy*O+dy*R |
| 0 0 1 | | P Q R | | P Q R |
参数：
- `sx` 水平比例因子
- `sy` 垂直比例因子
- `px` x轴
- `py` y轴
返回：`void`
---
### postScale
```cpp
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 | | sx*J sx*K sx*L |
S(sx, sy) * Matrix = | 0 sy 0 | | M N O | = | sy*M sy*N sy*O |
| 0 0 1 | | P Q R | | P Q R |
参数：
- `sx` 水平比例因子
- `sy` 垂直比例因子
返回：`void`
---
### postIDiv
```cpp
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 | | 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 |
参数：
- `divx` x逆比例的整数除数
- `divy` y逆比例的整数除数
返回：缩放成功返回true
---
### postRotate
```cpp
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+dx*P cK-sN+dx*Q cL-sO+dx+R|
R(degrees, px, py) * Matrix = |s c dy| |M N O| = |sJ+cM+dy*P sK+cN+dy*Q sL+cO+dy*R|
|0 0 1| |P Q R| | P Q R|
参数：
- `degrees` 坐标轴与垂直坐标轴的夹角
- `px` x轴
- `py` y轴
返回：`void`
---
### postRotate
```cpp
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
```cpp
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+kx*M+dx*P K+kx*N+dx*Q L+kx*O+dx+R|
K(kx, ky, px, py) * Matrix = |ky 1 dy| |M N O| = |ky*J+M+dy*P ky*K+N+dy*Q ky*L+O+dy*R|
| 0 0 1| |P Q R| | P Q R|
参数：
- `kx` 水平倾斜因子
- `ky` 垂直倾斜因子
- `px` x轴
- `py` y轴
返回：`void`
---
### postSkew
```cpp
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+kx*M K+kx*N L+kx*O |
K(kx, ky) * Matrix = | ky 1 0 | | M N O | = | ky*J+M ky*K+N ky*L+O |
| 0 0 1 | | P Q R | | P Q R |
参数：
- `kx` 水平倾斜因子
- `ky` 垂直倾斜因子
返回：`void`
---
### postConcat
```cpp
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
```cpp
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
```cpp
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
```cpp
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
```cpp
bool invert(Matrix* inverse) const {
if (this->isIdentity()) {
if (inverse) {
inverse->reset();
}
return true;
}
return this->invertNonIdentity(inverse);
};
```
矩阵反转，几何上，如果矩阵从源映射到目标，则逆矩阵从目标映射到源。如果矩阵不能被反转，逆矩阵不变
参数：
- `inverse` 要被反转的矩阵，可能是nullptr
返回：矩阵反转成功，返回true
---
### SetAffineIdentity
```cpp
static void SetAffineIdentity(float affine[6]);
```
在主序列中用标识值填充仿射
设置仿射：
| 1 0 0 |
| 0 1 0 |
OpenGL和XPS在主序列中仿射3x2矩阵
参数：
- `affine` 3x2仿射矩阵
返回：`void`
---
### asAffine
```cpp
bool asAffine(float affine[6]) const;
```
在主序列中填充仿射
设置仿射：
| scale-x skew-x translate-x |
| skew-y scale-y translate-y |
如果矩阵包含透视图，则返回false并保持仿射不变
参数：
- `affine` 3x2仿射矩阵，可能是nullptr
返回：如果矩阵不包含透视图，则返回true
---
### setAffine
```cpp
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
```cpp
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
```cpp
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
```cpp
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
```cpp
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
```cpp
bool mapRect(Rect* dst, const Rect& src) const;
```
将dst设置为矩阵映射的src角的边界，如果映射的角是dst角则返回true。返回值与调用rectStaysRect()方法相同
参数：
- `dst` 存储的映射点的边界
- `src` 要绘制的rect
返回：如果DST等价于映射的SRC，则为True
---
### mapRect
```cpp
bool mapRect(Rect* rect) const {
return this->mapRect(rect, *rect);
};
```
将rect设置为矩阵映射的矩形角的边界，如果映射的角是计算出来的矩形角，则返回true，返回值与调用rectStaysRect()相同
参数：
- `rect` 要映射的rect，并存储映射角的边界
返回：如果结果等价于映射的SRC，则为True
---
### mapRect
```cpp
Rect mapRect(const Rect& src) const {
Rect dst;
(void)this->mapRect(&dst, src);
return dst;
};
```
返回由矩阵映射的src角的边界
参数：
- `src` 要绘制的矩形
返回：映射的边界
---
### mapRectScaleTranslate
```cpp
void mapRectScaleTranslate(Rect* dst, const Rect& src) const;
```
将dst设置为矩阵映射的src角的边界，如果矩阵包含了缩放或转换以外的元素:如果SK_DEBUG被定义了则生效，否则结果为undefined
参数：
- `dst` 存储映射点的边界
- `src` 要绘制的Rect
返回：`void`
---
### cheapEqualTo
```cpp
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==
```cpp
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!=
```cpp
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
```cpp
void dump() const;
```
将矩阵的文本表示形式写入标准输出，浮点值的写入精度有限，可能无法重建原始矩阵的输出
参数：无
返回：`void`
---
### getMinScale
```cpp
float getMinScale() const;
```
通过分解缩放和倾斜元素，返回矩阵的最小缩放因子。如果比例因子溢出或矩阵包含透视图，则返回-1
参数：无
返回：最小缩放因子
---
### getMaxScale
```cpp
float getMaxScale() const;
```
通过分解缩放和倾斜元素，返回矩阵的最大缩放因子。如果比例因子溢出或矩阵包含透视图，则返回-1
参数：无
返回：最大缩放因子
---
### getMinMaxScales
```cpp
bool getMinMaxScales(float scaleFactors[2]) const;
```
将scaleFactors[0]设置为最小缩放因子，将scaleFactors[1]设置为最大缩放因子。缩放因子是通过分解矩阵缩放和倾斜元素来计算的。如果找到scaleFactors则返回true，否则，返回false，并将scaleFactors设置为未定义的值
参数：
- `scaleFactors` 最小和最大的缩放因子
返回：如果缩放因子计算正确，则返回true
---
### I
```cpp
static const Matrix& I();
```
返回对单位矩阵常量的引用，返回矩阵被设置为：
| 1 0 0 |
| 0 1 0 |
| 0 0 1 |
参数：无
返回：单位矩阵常量
---
### InvalidMatrix
```cpp
static const Matrix& InvalidMatrix();
```
返回指向一个值无效的常量矩阵的引用，返回矩阵被设置为：
| SK_ScalarMax SK_ScalarMax SK_ScalarMax |
| SK_ScalarMax SK_ScalarMax SK_ScalarMax |
| SK_ScalarMax SK_ScalarMax SK_ScalarMax |
参数：无
返回：无效的常量矩阵
---
### Concat
```cpp
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
```cpp
void dirtyMatrixTypeCache() {
this->setTypeMask(kUnknown_Mask);
};
```
将内部缓存设置为未知状态，用于在对操作符[](int index)返回的矩阵元素引用进行重复修改后强制更新
参数：无
返回：`void`
---
### setScaleTranslate
```cpp
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`
Reference in New Issue View Git Blame Copy Permalink