v4 - Simplify ColorspaceConverter

[JimBobSquarePants]

Motivation

The ColorspaceConverter codebase is overly large, complicated, and extremely difficult to expand upon. To add a new color space requires implementing converters from that space to every single existing space which is unmaintainable.

Color conversion ideally should be at most a two-step process and if we borrow the approach taken by ICC profiles, we can achieve that. ICC profiles use the concept of a Profile Connecting Space (PCS) which acts as a bridge between individual color spaces.

With C#11 we are able to implement static abstract methods in interfaces, which allows us to implement this design in a manner that allows simple expansion and ease of use.

The existing ColorSpaceConverter type only allows converting with a single set of options but with a simplified design it's possible to introduce static methods that allow conversion while passing options.

Implementation

Such an API would look like the following.

// Instance implementation
ColorConversionOptions options = default;
ColorSpaceConverter converter = new(options);
Cmyk cmyk = converter.Convert<Rgb, Cmyk>(rgb);

ReadOnlySpan<Rgb> rgbSpan = new Rgb[10];
Span<Cmyk> cmykSpan = new Cmyk[10];
converter.Convert<Rgb, Cmyk>(rgbSpan, cmykSpan);


// Static implementation
Cmyk cmyk = ColorSpaceConverter.Convert<Rgb, CieXyz, Cmyk, CieLab>(in options, rgb);

ReadOnlySpan<Rgb> rgbSpan = new Rgb[10];
Span<Cmyk> cmykSpan = new Cmyk[10];
ColorSpaceConverter.Convert<Rgb, CieXyz, Cmyk, CieLab>(in options, rgbSpan, cmykSpan);

The instance implementation can use fewer generic type parameters because it's possible to overload the parameters with known PCS spaces CieLab, CieXyz via extension methods.

The following three interfaces would be the backbone of all color spaces.

public interface IProfileConnectingSpace
{
    // Yes, this IS a marker interface.
}

public interface IProfileConnectingSpace<TSelf, TProfileSpace> : IProfileConnectingSpace
	where TSelf : IProfileConnectingSpace<TSelf, TProfileSpace>
	where TProfileSpace : struct, IProfileConnectingSpace
{
	public TProfileSpace ToProfileConnectingSpace(in ColorConversionOptions options);

	public static abstract TSelf FromProfileConnectingSpace(in ColorConversionOptions options, TProfileSpace source);

	public static abstract void ToProfileConnectionSpace(in ColorConversionOptions options, ReadOnlySpan<TSelf> source, Span<TProfileSpace> destination);

	public static abstract void FromProfileConnectionSpace(in ColorConversionOptions options, ReadOnlySpan<TProfileSpace> source, Span<TSelf> destination);
}

public interface IColorSpace<TSelf, TProfileSpace>
	where TSelf : IColorSpace<TSelf, TProfileSpace>
	where TProfileSpace : struct, IProfileConnectingSpace
{
	public TProfileSpace ToProfileConnectingSpace(in ColorConversionOptions options);

	public static abstract TSelf FromProfileConnectingSpace(in ColorConversionOptions options, TProfileSpace source);

	public static abstract void ToProfileConnectionSpace(in ColorConversionOptions options, ReadOnlySpan<TSelf> source, Span<TProfileSpace> destination);

	public static abstract void FromProfileConnectionSpace(in ColorConversionOptions options, ReadOnlySpan<TProfileSpace> source, Span<TSelf> destination);
}

We can implement the converter and static methods as simply as the following

public class ColorSpaceConverter
{

    public ColorSpaceConverter()
    : this(default)
    {
    }

    public ColorSpaceConverter(ColorConversionOptions options)
        => this.Options = options;

    public ColorConversionOptions Options { get; }

    public static TTo Convert<TFrom, TPcsFrom, TTo, TPcsTo>(in ColorConversionOptions options, TFrom source)
        where TFrom : struct, IColorSpace<TFrom, TPcsFrom>
        where TPcsFrom : struct, IProfileConnectingSpace<TPcsFrom, TPcsTo>, IProfileConnectingSpace<TPcsTo, TPcsFrom>
        where TTo : struct, IColorSpace<TTo, TPcsTo>
        where TPcsTo : struct, IProfileConnectingSpace<TPcsTo, TPcsFrom>, IProfileConnectingSpace<TPcsFrom, TPcsTo>
    {
        // Convert to input PCS
        TPcsFrom pcsFrom = source.ToProfileConnectingSpace(in options);

        // Convert between PCS
        TPcsTo pcsTo = TPcsTo.FromProfileConnectingSpace(in options, pcsFrom);

        // Convert to output from PCS
        return TTo.FromProfileConnectingSpace(in options, pcsTo);
    }

    public static void Convert<TFrom, TPcsFrom, TTo, TPcsTo>(in ColorConversionOptions options, ReadOnlySpan<TFrom> source, Span<TTo> destination)
        where TFrom : struct, IColorSpace<TFrom, TPcsFrom>
        where TPcsFrom : struct, IProfileConnectingSpace<TPcsFrom, TPcsTo>, IProfileConnectingSpace<TPcsTo, TPcsFrom>
        where TTo : struct, IColorSpace<TTo, TPcsTo>
        where TPcsTo : struct, IProfileConnectingSpace<TPcsTo, TPcsFrom>, IProfileConnectingSpace<TPcsFrom, TPcsTo>
    {
        // Convert to input PCS. We can use pooling here.
        Span<TPcsFrom> pcsFrom = new TPcsFrom[source.Length];
        TFrom.ToProfileConnectionSpace(in options, source, pcsFrom);

        // Convert between PCS. We can use pooling here.
        Span<TPcsTo> pcsTo = new TPcsTo[source.Length];
        TPcsFrom.ToProfileConnectionSpace(in options, pcsFrom, pcsTo);

        // Convert to output from PCS
        TTo.FromProfileConnectionSpace(in options, pcsTo, destination);
    }
}

Instance methods are implemented as extension methods split across multiple classes so that the compiler can handle the variation in generic type parameters.

For example...

public static class ColorSpaceConverterExtensionsCieLabCieXyz
{
    public static TTo Convert<TFrom, TTo>(this ColorSpaceConverter converter, TFrom source)
        where TFrom : struct, IColorSpace<TFrom, CieLab>
        where TTo : struct, IColorSpace<TTo, CieXyz>
    {
        ColorConversionOptions options = converter.Options;
        return ColorSpaceConverter.Convert<TFrom, CieLab, TTo, CieXyz>(in options, source);
    }

    public static void Convert<TFrom, TTo>(this ColorSpaceConverter converter, ReadOnlySpan<TFrom> source, Span<TTo> destination)
        where TFrom : struct, IColorSpace<TFrom, CieLab>
        where TTo : struct, IColorSpace<TTo, CieXyz>
    {
        ColorConversionOptions options = converter.Options;
        ColorSpaceConverter.Convert<TFrom, CieLab, TTo, CieXyz>(in options, source, destination);
    }
}

public static class ColorSpaceConverterExtensionsCieXyzCieLab
{
    public static TTo Convert<TFrom, TTo>(this ColorSpaceConverter converter, TFrom source)
        where TFrom : struct, IColorSpace<TFrom, CieXyz>
        where TTo : struct, IColorSpace<TTo, CieLab>
    {
        ColorConversionOptions options = converter.Options;
        return ColorSpaceConverter.Convert<TFrom, CieXyz, TTo, CieLab>(in options, source);
    }

    public static void Convert<TFrom, TTo>(this ColorSpaceConverter converter, ReadOnlySpan<TFrom> source, Span<TTo> destination)
        where TFrom : struct, IColorSpace<TFrom, CieXyz>
        where TTo : struct, IColorSpace<TTo, CieLab>
    {
        ColorConversionOptions options = converter.Options;
        ColorSpaceConverter.Convert<TFrom, CieXyz, TTo, CieLab>(in options, source, destination);
    }
}

Limitations

The static ColorSpaceConverter methods require all four generic type parameters to be provided and it's not possible to provide overloads for existing CieLab, CieXyz PCS types.

Implementing a new PCS type requires implementing a new interface on the existing PCS types. For example, CieLab would look like this out of the box.

public struct CieLab : IProfileConnectingSpace<CieLab, CieXyz>, IProfileConnectingSpace<CieXyz, CieLab>, IProfileConnectingSpace<CieLab, CieLab>

@SixLabors/core would love to hear your thoughts here. Members of the public are invited to comment also.