c++3D矩阵使用矢量性能较差

c++ 3D matrix using vector poor performance

本文关键字：性能 c++3D      更新时间：2023-10-16

你好，我正试图将这段matlab代码转换为c++。BTW也可以使用openCV。

imageData = toolbox.bayer.ColorOrder.cat( imageData, 0, 3);

这是之前的图像数据

1   2   3   4   5   6   7   8   9   10
11  12  13  14  15  16  17  18  19  20
21  22  23  24  25  26  27  28  29  30
31  32  33  34  35  36  37  38  39  40

这是之后的图像数据

val(：，：，1)=

1     3     5     7     9
21    23    25    27    29

val(：，：，2)=

2     4     6     8    10
22    24    26    28    30

val(：，：，3)=

11    13    15    17    19
31    33    35    37    39

val(：，：，4)=

12    14    16    18    20
32    34    36    38    40

这是我的c++代码，我正在获取int。**无法更改。。。

vector<vector<vector<double> > > Utilities::MatrixConcat(int **raw_frame, int _width, int _height)
{
vector<vector<vector<double> > > imageData;
imageData.resize(_height/2);
for (int i = 0; i < _height/2; ++i) 
{
imageData[i].resize(_width/2);
for (int j = 0; j < _width/2; ++j)
{
imageData[i][j].resize(4);
}
}
//[x][y][0]
for (int h = 0; h < _height/2; h++)
{       
for (int w = 0; w < _width/2; w++)
{           
imageData[h][w][0] = raw_frame[2*h][2*w];           
}
}
//[x][y][1]
for (int h = 0; h < _height/2; h++)
{       
for (int w = 0; w < _width/2; w++)
{           
imageData[h][w][1] = raw_frame[2*h][2*w+1];
}
}
for (int h = 0; h < _height/2; h++)
{       
for (int w = 0; w < _width/2; w++)
{           
imageData[h][w][2] = raw_frame[2*h+1][2*w];
}
}
for (int h = 0; h < _height/2; h++)
{       
for (int w = 0; w < _width/2; w++)
{           
imageData[h][w][3] = raw_frame[2*h+1][2*w+1];
}
}
return imageData;
}

我的问题是我的矩阵(不是用于测试的矩阵)是4000X3000，这意味着这个函数花费太长时间。你能解释一下是什么花了这么长时间，我该如何优化它吗？

我也可以使用openCV将这个2D矩阵转换为3D矩阵。

更新：

这是我为得到相同的结果而建立的测试

int** gili = new int*[4];
for (int i = 0; i < 4; i++)
{
gili[i] = new int[10];
} 
for (int i = 0,k=1; i < 4; i++)
{
for (int j = 0; j < 10; j++)
{
gili[i][j] = k;
k++;
}
}
vector<vector<vector<double> > > imageData = Utilities::MatrixConcat(gili,10,4);

您的代码有两个问题，数据结构和访问顺序。

数据结构
向量中的向量可能不是最有效的数据结构，因为通过索引运算符的每次访问都涉及一定程度的指针追逐。这可以通过使用迭代器(在可能的情况下)或围绕单个向量/数组构建包装器来缓解，该包装器允许您将三维位置转换为该容器的索引。

一个简单的3D矩阵实现可以是这样的：

class Matrix3D{
private:
size_t sizeX, sizeY, sizeZ;
std::vector<double> data;
size_t getIdx(size_t x, size_t y, size_t z) const {
return x + sizeX*y + sizeX*sizeY*z;
}
public:
Matrix3D(size_t X, size_t Y, size_t Z) :sizeX(X), sizeY(Y), sizeZ(Z),data(X*Y*Z){}
double& operator()(size_t x, size_t y, size_t z){ return data[getIdx(x, y, z)]; }
double operator() (size_t x, size_t y, size_t z) const{ return data[getIdx(x, y, z)]; }
//arithmetic operators
};

或者，如果维度是编译时间常数：

template<size_t sizeX, size_t sizeY, size_t sizeZ>
class Matrix3D_ConstDim{
private:    
std::unique_ptr<std::array<double,sizeX*sizeY*sizeZ>> data;
size_t getIdx(size_t x, size_t y, size_t z) const {
return x + sizeX*y + sizeX*sizeY*z;
}
public:
Matrix3D_ConstDim(){
data = std::make_unique<std::array<double, sizeX*sizeY*sizeZ>>();
}
double& operator()(size_t x, size_t y, size_t z){ return (*data)[getIdx(x, y, z)]; }
double operator() (size_t x, size_t y, size_t z) const{ return (*data)[getIdx(x, y, z)]; }
//arithmetic operators
};

用法：

int main() {
Matrix3D m1(10, 5, 4);
m1(1, 2, 3) = 4.5;
std::cout << m1(1, 2, 3) << std::endl;
Matrix3D_ConstDim<10, 5, 4> m2;
m2(1, 2, 3) = 4.5;
std::cout << m2(1, 2, 3) << std::endl;
}

元素访问
第二件事(可能更重要)是顺序访问。如果您想迭代矩阵中的所有元素，请确保访问这些元素的顺序与它们在内存中的排列顺序相同。因此几乎所有的访问都会导致缓存命中(即使当缓存行中的第一个元素被访问时，由于预取，您也有很高的机会获得l1缓存命中。它还可能允许编译器执行代码的自动复盖。这意味着编译器将使用特殊指令，同时执行循环的多次迭代。
如果您想初始化上述矩阵，代码可能如下所示这个：

for (size_t z = 0; z < 4; ++z){
for (size_t y = 0; y < 4; ++y){
for (size_t x = 0; x < 4; ++x){ //<-- inner most loop changes X
m1(x, y, z) = x*(y + 1)*(z + 2); //<-- arbitrary values
}
}
}
相关文章：