v4 Promote PixelTypeInfo to TPixel

[JimBobSquarePants]

Motivation

PixelTypeInfo is a type used to determine various qualities of a give TPixel format in order to drive correct behavior for pixel operation. The type is currently loosely coupled with TPixel types being lazily invoked on creation of PixelOperations<T>.

With C#11 we are able to implement static abstract methods in interfaces, which allows us to reimplement the type as the result of a static method on the generic type. This tightly couples the information making it far more useful in multiple scenarios. In addition, it removes the overhead of lazily invoking the type.

Implementation

The signature of the type would be changed to a generic one in addition to changing the type to a value type readonly struct.
This allows us greater scope for further expansion of the type properties and performance improvements.

public interface IPixel
{
    // Non-generic methods...
}

public interface IPixel<TSelf> : IPixel, IEquatable<TSelf>
    where TSelf : unmanaged, IPixel<TSelf>
{
    static abstract PixelTypeInfo GetPixelTypeInfo();

    PixelOperations<TSelf> CreatePixelOperations();
}

public readonly struct PixelTypeInfo
{
    public byte BytesPerPixel { get; init; }

    public byte ComponentCount { get; init; }

    public PixelAlphaRepresentation PixelAlphaRepresentation { get; init; }

    // Other properties...

    internal static PixelTypeInfo Create<TPixel>(byte componentCount, PixelAlphaRepresentation pixelAlphaRepresentation)
        where TPixel : unmanaged, IPixel<TPixel>
        => new()
        {
            BytesPerPixel = (byte)(Unsafe.SizeOf<TPixel>() * 8),
            ComponentCount = componentCount,
            PixelAlphaRepresentation = pixelAlphaRepresentation
        };
}

public struct Rgba32 : IPixel<Rgba32>
{
    public static PixelTypeInfo GetPixelTypeInfo()
        => PixelTypeInfo.Create<Rgba32>(4, PixelAlphaRepresentation.Unassociated);

    public PixelOperations<Rgba32> CreatePixelOperations()
    {
        throw new NotImplementedException();
    }

    public bool Equals(Rgba32 other)
    {
        throw new NotImplementedException();
    }

    // Other properties and methods..
}

public class PixelOperations<TPixel>
    where TPixel : unmanaged, IPixel<TPixel>
{
    public static PixelTypeInfo GetPixelTypeInfo() => TPixel.GetPixelTypeInfo();

    // Other methods...
}

Limitations

None known.

[tocsoft]

does PixelTypeInfo<TPixel> even need to be kept or can the metadata it exposes be exposed directly as statics from TPixel itself?
i.e.

public interface IPixel<TSelf> : IPixel, IEquatable<TSelf>
    where TSelf : unmanaged, IPixel<TSelf>
{
      static abstract int BytesPerPixel { get; }
      static abstract uint ComponentCount { get; }
     ... etc
}

public struct Rgba32 : IPixel<Rgba32>
{
    public static int BytesPerPixel { get; } = Unsafe.SizeOf<TPixel>() * 8;
    public static int ComponentCount{ get; } = 4;
}

[JimBobSquarePants]

I'd probably keep it as we'd likely expand upon it as we find other use cases once we expose the information on TPixel itself. PixelAlphaRepresentation is missing in my example code for starters.

[antonfirsov]

PixelTypeInfo is also being used to expose metadata of the original pixel type in Identify:

ImageSharp/src/ImageSharp/ImageInfo.cs

Lines 20 to 26 in 54b7e04

	public ImageInfo(
	PixelTypeInfo pixelType,
	Size size,
	ImageMetadata? metadata)
	: this(pixelType, size, metadata, null)
	{
	}

ImageSharp/src/ImageSharp/Formats/Png/PngDecoderCore.cs

Line 373 in 54b7e04

return new ImageInfo(new PixelTypeInfo(this.CalculateBitsPerPixel()), new(this.header.Width, this.header.Height), metadata);

This is a useful feature we should not remove. We should consider adding it to ImageMetadata too so this information is also available on Load/Decode.

Note, that with that PixelTypeInfo can't be generic. In fact even if we didn't use it for this purpose, it should not be made a generic type, storing BytesPerPixel in a member is cheaper than the runtime cost of JITting several generic instantiations of an entire type.

[JimBobSquarePants]

Very valid point!! I completely forgot about the metadata usage. I've updated the proposal to reflect that.

[JimBobSquarePants]

I'd like to also add information to the type to express how components are represented. This would allow us to create conversions to Color while ensuring we use the correct boxed pixel.

Something like the following:

public enum PixelComponentPrecision
{
    Byte,       // 8-bit unsigned integer
    Short,      // 16-bit signed integer
    UShort,     // 16-bit unsigned integer
    Int,        // 32-bit signed integer
    UInt,       // 32-bit unsigned integer
    Float,      // 32-bit floating point
    Double,     // 64-bit floating point
    Half,       // 16-bit floating point 
    // ... any other numeric types you might need
}

[antonfirsov]

How would the precision information be used exactly? Do you have pseudo code?

Wouldn't the following (or some equivalent trick) be enough/simpler?

public interface IPixel
{
    abstract Color ToColor();
}

public interface IPixel<TSelf> : IPixel
{
    // First level heuristic implementation. Optimize in pixel implementations.
    override Color ToColor()
    {
        if (Unsafe.SizeOf<TSelf>() <= Unsafe.SizeOf<Rgba64>())
        {
            Rgba32 p = default;
            this.ToRgba64(ref p); // Needs an IPixel.ToRgba64() addition
            return new Color(p); // Make Color(IPixel) internal. 
        }
        else
        {
            return new Color(this);
        }
    }
}

[JimBobSquarePants]

Something like the following...

public static Color FromPixel<TPixel>(TPixel pixel)
    where TPixel: unmanaged, IPixel<TPixel>
{
    if(TPixel.GetPixelTypeInfo().PixelComponentPrecision == PixelComponentPrecision.Byte)
    {
        // Use Rgba32 as boxed pixel.
    }
        // Use Rgba64 as boxed pixel.
}

With that knowledge in hand, you could probably lose the current limited pixel-based Color constructors.

I'd wager there'd be other uses for the property in the future though. Maybe optimization opportunities for custom code.