3D 数组和 2D 对象数组之间的 C# 性能

Question

I'm working on a project where I open and manipulate an image file. Until now I was using the Bitmap class but I recently decided to instead make my own class for the image. I want to have two dimensions, X and Y, for fetching the pixels, but rather than each pixel being a Color I want another dimension where I can encode additional data. For example, I want an additional int that can flag other methods to ignore a particular pixel.

My question is, should I make a pixel object and add fields to it, then make a 2D array of pixels? Or should I just make a 3D array?

The image will probably be up to 3000 pixels wide/high and I'll probably want up to 10 fields. So what would be the more efficient option? If it's negligible I would prefer the ease of creating an object.

Answer 1

It has been demonstrated that 2D arrays are a lot slower than 1D arrays in C#.

Typically you would pack a 2D array into a long 1D array, laying it down row by row. You use this as a 2D array but internally is a 1D array.

static class Program
{
    static void Main(string[] args)
    {
        var image = new Matrix<MyColor>(3000, 3000);

        MyColor pixel = image[374, 991];
        image[867, 1723] = new MyColor(Color.Chartreuse, 1001, -1);
    }
}

In your case, the element of the array can be to your own struct with the fields you want.

public readonly struct MyColor
{
    public MyColor(Color color, int x1, int x2)
    {
        this.Color = color;
        this.Value1 = x1;
        this.Value2 = x2
    }
    public Color Color { get; }
    public int Value1 { get; }
    public int Value2 { get; }
}

the basic idea for coding a packed array matrix follows:

public class Matrix<T> : ICollection<T>, System.Collections.ICollection
{
    readonly T[] data;

    public Matrix(int rows, int columns)
    {
        this.data = new T[rows * columns];
        this.Rows = rows;
        this.Columns = columns;
    }
    public Matrix(T[] data, int rows, int columns)
    {
        this.data = data;
        this.Rows = rows;
        this.Columns = columns;
    }

    public int Rows { get; }
    public int Columns { get; }

    public ref T this[int row, int column]
        => ref data[row*Columns+column];

    // other code here

    public static implicit operator T[,](Matrix<T> matrix)
        => matrix.data.Unpack(matrix.Rows, matrix.Columns);
}

and in the end, if you want to convert a 1D array into a 2D array and back you can do it fast using the following extensions methods/utilities.

public static class ArrayEx
{
    /// <summary>
    /// Create a copy of an array with new size.
    /// </summary>
    /// <param name="array">The input array.</param>
    /// <param name="length">The desired length.</param>
    public static T[] Resize<T>(this T[] array, int length)
    {
        T[] result = new T[length];
        var byteCount = Math.Min(Buffer.ByteLength(array), Buffer.ByteLength(result));
        Buffer.BlockCopy(array, 0, result, 0, byteCount);
        return result;
    }

    /// <summary>
    /// Create a copy of a matrix with new size.
    /// </summary>
    /// <param name="matrix">The input matrix.</param>
    /// <param name="rows">The desired rows.</param>
    /// <param name="columns">The desired columns.</param>
    public static T[,] Resize<T>(this T[,] matrix, int rows, int columns)
    {
        T[,] result = new T[rows, columns];
        var byteCount = Math.Min(Buffer.ByteLength(matrix), Buffer.ByteLength(result));
        Buffer.BlockCopy(matrix, 0, result, 0, byteCount);
        return result;
    }

    /// <summary>
    /// Pack a 2D matrix into an array.
    /// </summary>
    /// <param name="matrix">The input matrix.</param>
    /// <param name="length">The desired length or zero for best fit.</param>
    public static T[] Pack<T>(this T[,] matrix, int length = 0)
    {
        length = Math.Max(matrix.Length, length);
        T[] result = new T[length];
        var byteCount = Math.Min(Buffer.ByteLength(matrix), Buffer.ByteLength(result));
        Buffer.BlockCopy(matrix, 0, result, 0, byteCount);
        return result;
    }

    /// <summary>
    /// Unpack an array into a 2D matrix
    /// </summary>
    /// <param name="array">The input array.</param>
    /// <param name="rows">The number rows requested.</param>
    /// <param name="columns">The number of columns requested, 
    /// or zero for best fit.</param>
    public static T[,] Unpack<T>(this T[] array, int rows, int columns = 0)
    {
        if (columns == 0)
        {
            columns = (int)Math.Ceiling(array.Length / (1f * rows));
        }
        int length = Math.Max(array.Length, rows * columns);
        T[,] result = new T[rows, columns];
        var byteCount = Math.Min(Buffer.ByteLength(array), Buffer.ByteLength(result));
        Buffer.BlockCopy(array, 0, result, 0, byteCount);
        return result;
    }
}

---

Edit 1

I think Buffer.BlockCopy() only works for primitives types. For user types, there are limited options to do a fast memory copy from a 2D array to a 1D and back. Internally the CLR stores 2D arrays row by row, as a 1D array, but there is no easy way to expose the internal data storage.