Question

我有一个winform桌面C＃应用程序。

我的图片大小为720x576。

图像由3维字节数组表示： 720x576x3。

x3表示红色，绿色和蓝色的3种颜色通道。

此图像按逻辑划分（出于我的目的）分为4个区域，如下所示：

enter image description here

假设我有一个用于Region 4的新字节数组，我希望更新这个'Base'数组。

我可以这样做：

         for (Int16 camIndex = 0; camIndex < 4; camIndex++)
            {
                if (camsChanged[camIndex])
                {
                    Rectangle roi = Rectangle.Empty;
                    switch (camIndex)
                    {
                        case 0:
                            roi = new Rectangle(0, 0, 360, 288);
                            break;
                        case 1:
                            roi = new Rectangle(360, 0, 360, 288);
                            break;
                        case 2:
                            roi = new Rectangle(0, 288, 360, 288);
                            break;
                        case 3:
                            roi = new Rectangle(360, 288, 360, 288);
                            break;
                    }
                    for (int x = roi.X; x < roi.X + roi.Width; x++)
                    {
                        for (int y = roi.Y; y < roi.Y + roi.Height; y++)
                        {                              
                            BaseImage[x, y, 0] = NewBaseImage[x, y, 0]; //signifies Red Channel
                            BaseImage[x, y, 1] = NewBaseImage[x, y, 1]; //signifies Green Channel 
                            BaseImage[x, y, 2] = NewBaseImage[x, y, 2]; //signifies Yellow Channel
                        }
                    }
                }
            }

但是有更快的方法吗？我查看了Buffer.BlockCopy和Array.Copy，但我看不出它在这种情况下如何帮助我，因为它想要替换整个'Base'数组？

由于

Answer 1

Array.Copy消除了对每个索引调用进行边界检查的需要（因此运行得更快）。这里最大的问题是你正在处理一个多维数组。因为你关心速度，你应该扁平化为单维数组。这个问题涉及扁平化和索引（How to "flatten" or "index" 3D-array in 1D array?）

我个人没有太多使用BlockCopy的经验，但Array.Copy比单独复制每个项目产生更好的性能。

修改

我想到你实际上可以在多维数组上调用Array.Copy，但是你必须传递计算的索引值。不幸的是，你们四个区域并没有排列成连续的区块。看看这个更简单的（2-d）示例来说明问题：

int[,] a = new int[4,4]; int quadrent = 1; for (int x = 0; x < 4; x++) { for (int y = 0; y < 4; y++) { if (x < 2) { if (y < 2) { quadrent = 1; } else { quadrent = 2; } } else { if (y < 2) { quadrent = 3; } else { quadrent = 4; } } a[x, y] = quadrent; } } int i, j; /* output each array element's value */ for (i = 0; i < 4; i++) { Console.WriteLine(String.Format("{0}, {1}, {2}, {3}", a[i, 0], a[i, 1], a[i, 2], a[i, 3])); } //split the line; Console.WriteLine(); Console.WriteLine(); Array.Copy(a, 0, a, 11, 4); for (i = 0; i < 4; i++) { Console.WriteLine(String.Format("{0}, {1}, {2}, {3}", a[i, 0], a[i, 1], a[i, 2], a[i, 3])); } Console.ReadKey();

输出：

1, 1, 2, 2 1, 1, 2, 2 3, 3, 4, 4 3, 3, 4, 4 1, 1, 2, 2 1, 1, 2, 2 3, 3, 4, 1 1, 2, 2, 4

因此，您将无法在整个区域上调用Array.Copy，但您可以在代码的连续段上调用它。你有第三维的事实会增加复杂性，但它应该是可能的。这样就不需要直接压扁，但是你仍然需要循环切片。话虽这么说，你仍然应该看到可测量的速度提升。

Answer 2

感谢您更新问题。现在我可以使用Buffer.BLockCopy()回答。我已经停留了一段时间，但我得到了很好的工作。这是概念证明代码：

public enum CameraPos
{
    TopLeft = 0,
    TopRight = 1,
    BottomLeft = 2,
    BottomRight = 3
}

class Program
{
    static void Main(string[] args)
    {
        const int W=360, H=288;

        var BaseImage=new short[2*W, 2*H, 3];

        // Initialize sequential numbers so I can debug the results easier.
        short num=0;
        for (int x=0; x<2*W; x++)
        {
            for (int y=0; y<2*H; y++)
            {
                // num = color + 3*( y+576*x )
                BaseImage[x, y, 0]=num++;
                BaseImage[x, y, 1]=num++;
                BaseImage[x, y, 2]=num++;
            }
        }

        var NewImage=new short[2*W, 2*H, 3];

        CopySubImage(BaseImage, NewImage, CameraPos.TopRight);
        // this copied x=360..719 and y=0..287
    }

    static void CopySubImage(short[, ,] base_image, short[, ,] new_image, CameraPos cam_index)
    {
        int W=base_image.GetLength(0)/2;
        int H=base_image.GetLength(1)/2;

        int x_index=((int)cam_index%2)*W;  // either 0 or 360
        // int y_index=((int)cam_index/2)*H;  // either 0 or 288 (not needed)

        // Copy columns with Buffer.BlockCopy. Shown below are the flat array indeces.
        //
        // | 3*(0+576*0) 3*(0+576*1) .. 3*(0+576*359) | 3*(0+576*360)   .. 3*(0+576*719)   |
        // | 3*(1+576*0) 3*(1+576*1) .. 3*(1+576*359) | 3*(1+576*360)   .. 3*(1+576*719)   |
        // |     ..                           ..      |       ..               ..          |
        // | 3*(287+576*0)      ..    3*(287+576*359) | 3*(287+576*360) .. 3*(287+576*719) |
        // + ---------------------------------------- + ---------------------------------- +
        // | 3*(288+576*0)      ..    3*(288+576*359) | 3*(288+576*360) .. 3*(288+576*719) |
        // |     ..                           ..      |       ..               ..          |
        // | 3*(575+576*0)      ..    3*(575+576*359) | 3*(575+576*360) .. 3*(575+576*719) |

        for (int x=x_index; x<x_index+W; x++)
        {
            int k_start=3*(y_index+2*H*x);
            //int k_end=3*(x_index+W+720*y); (not needed)

            Buffer.BlockCopy(base_image, k_start, new_image, k_start, 3*H*sizeof(short));
        }
    }
}

复制3维字节数组的最快方法是替换另一个3维字节数组的PART

2 个答案: