c# - 复制 3 维字节数组以替换另一个 3 维字节数组的 PART 的最快方法

Question

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

我有一张尺寸为 720x576 的图片。

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

x3 代表红、绿、蓝 3 个颜色 channel 。

这张图片在逻辑上(为了我的目的)分为 4 个区域，如下所示:

假设我有一个用于区域 4 的新字节数组，我希望更新这个“基本”数组。

我可以这样做:

         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

感谢您更新问题。现在我可以使用 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));
        }
    }
}