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

Question

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

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

这是imageData之前

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);

Answer 1

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

数据结构
向量的向量向量可能不是最有效的数据结构，因为通过索引运算符的每次访问都涉及某种程度的指针追逐。 通过使用迭代器（可能的话）可以在某种程度上缓解这种情况，或者在单个向量/数组周围构建包装器，从而可以将三维位置转换为该容器的索引。

一个简单的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
            }
        }
    }