快速数据结构或算法，以查找图像堆栈中每个像素的平均值

Question

我有一堆图像，我想在其中计算堆栈中每个像素的平均值。

例如，let (x_n,y_n)是第n个图像中的(x,y)像素。 因此，图像堆栈中三个图像的像素(x,y)的平均值是：

mean-of-(x,y) = (1/3) * ((x_1,y_1) + (x_2,y_2) + (x_3,y_3))

我的第一个想法是将每个图像的所有像素强度加载到具有单个线性缓冲区的数据结构中，如下所示：

|All pixels from image 1| All pixels from image 2| All pixels from image 3|

为了找到图像堆栈中像素的总和，我执行一系列嵌套for循环，如下所示：

for(int col=0; col<img_cols; col++)
{
    for(int row=0; row<img_rows; row++)
    {
        for(int img=0; img<num_of_images; img++)
        {
            sum_of_px += px_buffer[(img*img_rows*img_cols)+col*img_rows+row];
        }
    }
}

基本上img*img_rows*img_cols给出第n个图像中第一个像素的缓冲元素， col*img_rows+row给出我想要为堆栈中的每个n图像找到的(x,y)像素。

是否有一种数据结构或算法可以帮助我将图像堆栈中的像素强度总结得比我当前的实现更快，更有条理？

我的目标是可移植性，所以我不会使用OpenCV并且在linux上使用C ++。

Answer 1

问题中嵌套循环的问题是它不是非常缓存友好的。 你可以通过长距离跳过内存，有效地使你的数据缓存无用。 你将花费大量时间来访问内存。

如果您可以节省内存，则可以创建一个额外的图像大小的缓冲区，以便在按内存顺序遍历所有图像中的所有像素时累积每个像素的总计。 然后你通过缓冲区进行单次传递。

您的累积缓冲区可能需要使用比单个像素值更大的类型，因为它必须累积其中的许多像素值。 如果你的像素值是8位整数，那么你的累加缓冲区可能需要32位整数或浮点数。

Answer 2

通常，一堆像素

(x_1,y_1),...,(x_n,y_n)

有条件地独立于堆栈

(a_1,b_1),...,(a_n,b_n) 

即使它们不是（假设一个特定的数据集），那么对它们的交互进行建模是一项复杂的任务，只会给你一个平均值的估计。 因此，如果您想计算每个堆栈的精确平均值，则除了迭代您提供的三个循环之外，您没有任何其他选择。 诸如Matlab / octave之类的语言和诸如Theano（python）或Torch7（lua）之类的库都将这些迭代并行化。 如果您使用的是C ++，那么您所做的就非常适合Cuda或OpenMP。 至于可移植性，我认为OpenMP是更容易的解决方案。

Answer 3

专门用于平均计算的便携式快速数据结构可以是：

std::vector<std::vector<std::vector<sometype> > > VoVoV;
VoVoV.resize(img_cols);
int i,j;
for (i=0 ; i<img_cols ; ++i)
{
  VoVoV[i].resize(img_rows);
  for (j=0 ; j<img_rows ; ++j)
  {
    VoVoV[i][j].resize(num_of_images);
    // The values of all images at this pixel are stored continguously,
    // therefore should be fast to access.
  }
}

VoVoV[col][row][img] = foo;

作为旁注，示例中的1/3将评估为0 ，这不是您想要的。

要快速求和/平均，您现在可以：

sometype sum = 0;
std::vector<sometype>::iterator it     = VoVoV[col][row].begin();
std::vector<sometype>::iterator it_end = VoVoV[col][row].end();
for ( ; it != it_end ; ++it)
  sum += *it;
sometype avg = sum / num_of_images; // or similar for integers; check for num_of_images==0

基本上你不应该依赖于编译器会优化掉总是相同偏移的重复计算。