如何使用任务将图像的字节数组拆分为多个字节数组

Question

目标：

我正在制作一个简单的图像处理应用程序，它使用 Tasks 进行多线程处理。用户从文件夹中选择图像并将其显示在 PicBox 中。当他输入线程数、要改变的colorType和该colorType(R,G,B)的Value(0-255)，然后点击编辑按钮，图像为：

程序

1. 转换为字节数组
2. 返回字节数组，并根据线程号计算主元。
3. 创建任务列表，并为每个任务分配一个较大字节数组的开始和结束索引
4. 在该方法中，将较大字节的小部分（从开始到结束索引）保存到较小的字节数组中
5. 该方法然后将小字节数组转换为Image并返回图像

问题：

一切都很好，直到第五步我尝试将字节数组转换为图像。它特别发生在开始索引大于 0 时，即在第二个任务执行期间。它适用于第一个任务。难道是它不能接受开始索引> 0？

请查看以下代码：

代码

                List<Task<Image>> processImgTask = new List<Task<Image>>(threadCount);

                threadCount = Convert.ToInt32(threadCombox.SelectedItem);
                interval = imgArray.Length / threadCount;

                for (int i = 0; i < threadCount; i++)
                {
                    Start = End;
                    End += interval;
                    if (i == threadCount - 1)
                    {
                        End = imgArray.Length;
                    }
                    object data = new object[3] { Start, End, imgArray };
                    processImgTask.Add(new Task<Image>(ImgProcess, data));
                }
                //Task.WaitAll(processImgTask);

                //EDIT followed by comments and answer
                Parallel.ForEach(processImgTask, task =>
                {
                    task.Start();
                    taskPicbox.Image = task.Result;
                });



    private Image ImgProcess(object data)
    {
        object[] indexes = (object[])data;
        int Start=(int)indexes[0];
        int End = (int)indexes[1];            
        byte[] img = (byte[])indexes[2];

        List<byte> splitArray = new List<byte>();
        for (int i =Start;i<End;i++)
        {
            splitArray.Add(img[i]);
        }
        byte[] b = splitArray.ToArray();

        //Error occurs here when task 2 (thread 2) is being executed->
            Image x = (Bitmap)((new ImageConverter()).ConvertFrom(b));
        //System.ArgumentException: 'Parameter is not valid.'                    
        return x;
    }

Answer 1

在 how to convert a byte array with raw pixeldata to an bitmap 上查看此答案。

我还强烈建议使用 Parallel.For 而不是任务。任务旨在异步运行代码，即允许计算机在等待数据的同时执行操作。 Parallel.For/Foreach 旨在同时运行代码，即使用多个内核以获得更好的性能。 Async and parallel is not the same.

我还建议您从一个简单的单线程实现开始，无论您尝试做什么。处理器快速，除非您正在做一些要求很高的事情，否则开销可能很大。虽然并行化可能使您的代码运行速度提高四倍（或者无论您拥有多少 CPU 内核），但其他优化通常可以将性能提高数百倍或更多。如果需要，您可以随时并行化。

对于图像，进行并行化的典型方法是对图像中的每一行进行并行处理。

Answer 2

作为对 JonasH 的回应，我为你做了一个例子。此示例使用 Span 类型。可以直接使用数组或ArraySegment<byte>。

这是一个如何处理多线程行的示例：

private void Main()
{
    int width = 1024;
    int height = 768;
    int channelCount = 3;

    // create a buffer
    var data = new byte[width * height * channelCount];

    // fill with some data
    // example: 0, 1, 2, 3, 4, 5, 6
    PutSomeValuesInThatBuffer(data);

    // process the image and specify a line-edit callback
    // transforms to: 255, 254, 253, 252, 251, 250
    ProcessImage(data, width, height, channelCount, linePixels =>
    {
        int offset = 0;

        // we need to loop all pixel on this line
        while (offset < linePixels.Length)
        {
            // for RGB | R = channel[0], G = channel[1], B = channel[2], etc...

            // lets invert the colors, this loop isn't quite necessary
            // but it shows the use of channels  (R, G, B)  
            for (int i = 0; i < channelCount; i++)
            {
                linePixels[offset] = 255 - linePixels[offset];
                offset++;
            }
        }
    });
}

---

public delegate void LineProcessorAction(Span<byte> line);

// this is the process method which will split the data into lines 
// and process them over multiple threads.
private void ProcessImage(
    byte[] data,
    int width, int height, int channelCount,
    LineProcessorAction lineProcessor)
{
    var rowSizeInBytes = width * channelCount;

    Parallel.For(0, height, index => 
        lineProcessor(new Span<byte>(data, index * rowSizeInBytes, rowSizeInBytes)));
}

---

private static void PutSomeValuesInThatBuffer(byte[] data)
{
    for (int i = 0; i < data.Length; i++)
        data[i] = (byte)i;
}