Color conversion with ICC profiles

src/ImageSharp/ColorSpaces/Conversion/Implementation/Icc/Calculators/ClutCalculator.cs

@@ -0,0 +1,104 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorSpaces.Conversion.Icc;
+
+internal class ClutCalculator : IVector4Calculator
+{
+    private readonly int inputCount;
+    private readonly int outputCount;
+    private readonly float[][] lut;
+    private readonly byte[] gridPointCount;
+    private readonly int[] indexFactor;
+    private readonly int nodeCount;
+    private readonly float[][] nodes;
+
+    public ClutCalculator(IccClut clut)
+    {
+        Guard.NotNull(clut, nameof(clut));
+
+        this.inputCount = clut.InputChannelCount;
+        this.outputCount = clut.OutputChannelCount;
+        this.lut = clut.Values;
+        this.gridPointCount = clut.GridPointCount;
+        this.indexFactor = CalculateIndexFactor(clut.InputChannelCount, clut.GridPointCount);
+        this.nodeCount = (int)Math.Pow(2, clut.InputChannelCount);
+        this.nodes = new float[this.nodeCount][];
+    }
+
+    public unsafe Vector4 Calculate(Vector4 value)
+    {
+        Vector4 result = default;
+        this.Interpolate((float*)&value, this.inputCount, (float*)&result, this.outputCount);
+
+        return result;
+    }
+
+    private static int[] CalculateIndexFactor(int inputCount, byte[] gridPointCount)
+    {
+        int[] factors = new int[inputCount];
+        int gpc = 1;
+        for (int j = inputCount - 1; j >= 0; j--)
+        {
+            factors[j] = gpc * (gridPointCount[j] - 1);
+            gpc *= gridPointCount[j];
+        }
+
+        return factors;
+    }
+
+    private unsafe void Interpolate(float* values, int valueLength, float* result, int resultLength)
+    {
+        for (int i = 0; i < this.nodes.Length; i++)
+        {
+            int index = 0;
+            for (int j = 0; j < valueLength; j++)
+            {
+                float fraction = 1f / (this.gridPointCount[j] - 1);
+                int position = (int)(values[j] / fraction) + ((i >> j) & 1);
+                index += (int)((this.indexFactor[j] * (position * fraction)) + 0.5f);
+            }
+
+            // TODO: The CMYK profile in our tests causes an out of range exception
+            // against 'lut'. Clamping the index leads to incorrect results.
+            this.nodes[i] = this.lut[index];
+        }
+
+        Span<float> factors = stackalloc float[this.nodeCount];
+        for (int i = 0; i < factors.Length; i++)
+        {
+            float factor = 1;
+            for (int j = 0; j < valueLength; j++)
+            {
+                float fraction = 1f / (this.gridPointCount[j] - 1);
+                int position = (int)(values[j] / fraction);
+
+                float low = position * fraction;
+                float high = (position + 1) * fraction;
+                float percentage = (high - values[j]) / (high - low);
+
+                if (((i >> j) & 1) == 1)
+                {
+                    factor *= percentage;
+                }
+                else
+                {
+                    factor *= 1 - percentage;
+                }
+            }
+
+            factors[i] = factor;
+        }
+
+        for (int i = 0; i < resultLength; i++)
+        {
+            for (int j = 0; j < this.nodes.Length; j++)
+            {
+                result[i] += this.nodes[j][i] * factors[j];
+            }
+        }
+    }
+}

src/ImageSharp/ColorSpaces/Conversion/Implementation/Icc/Calculators/ColorTrcCalculator.cs

@@ -0,0 +1,51 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorSpaces.Conversion.Icc;
+
+internal class ColorTrcCalculator : IVector4Calculator
+{
+    private readonly TrcCalculator curveCalculator;
+    private Matrix4x4 matrix;
+    private readonly bool toPcs;
+
+    public ColorTrcCalculator(
+        IccXyzTagDataEntry redMatrixColumn,
+        IccXyzTagDataEntry greenMatrixColumn,
+        IccXyzTagDataEntry blueMatrixColumn,
+        IccTagDataEntry redTrc,
+        IccTagDataEntry greenTrc,
+        IccTagDataEntry blueTrc,
+        bool toPcs)
+    {
+        this.toPcs = toPcs;
+        this.curveCalculator = new TrcCalculator(new IccTagDataEntry[] { redTrc, greenTrc, blueTrc }, !toPcs);
+
+        Vector3 mr = redMatrixColumn.Data[0];
+        Vector3 mg = greenMatrixColumn.Data[0];
+        Vector3 mb = blueMatrixColumn.Data[0];
+        this.matrix = new Matrix4x4(mr.X, mr.Y, mr.Z, 0, mg.X, mg.Y, mg.Z, 0, mb.X, mb.Y, mb.Z, 0, 0, 0, 0, 1);
+
+        if (!toPcs)
+        {
+            Matrix4x4.Invert(this.matrix, out this.matrix);
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Vector4 Calculate(Vector4 value)
+    {
+        if (this.toPcs)
+        {
+            value = this.curveCalculator.Calculate(value);
+            return Vector4.Transform(value, this.matrix);
+        }
+
+        value = Vector4.Transform(value, this.matrix);
+        return this.curveCalculator.Calculate(value);
+    }
+}

src/ImageSharp/ColorSpaces/Conversion/Implementation/Icc/Calculators/CurveCalculator.CalculationType.cs

@@ -0,0 +1,14 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.ColorSpaces.Conversion.Icc;
+
+internal partial class CurveCalculator
+{
+    private enum CalculationType
+    {
+        Identity,
+        Gamma,
+        Lut,
+    }
+}

src/ImageSharp/ColorSpaces/Conversion/Implementation/Icc/Calculators/CurveCalculator.cs

@@ -0,0 +1,46 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+#nullable disable
+
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorSpaces.Conversion.Icc;
+
+internal partial class CurveCalculator : ISingleCalculator
+{
+    private readonly LutCalculator lutCalculator;
+    private readonly float gamma;
+    private readonly CalculationType type;
+
+    public CurveCalculator(IccCurveTagDataEntry entry, bool inverted)
+    {
+        if (entry.IsIdentityResponse)
+        {
+            this.type = CalculationType.Identity;
+        }
+        else if (entry.IsGamma)
+        {
+            this.gamma = entry.Gamma;
+            if (inverted)
+            {
+                this.gamma = 1f / this.gamma;
+            }
+
+            this.type = CalculationType.Gamma;
+        }
+        else
+        {
+            this.lutCalculator = new LutCalculator(entry.CurveData, inverted);
+            this.type = CalculationType.Lut;
+        }
+    }
+
+    public float Calculate(float value)
+        => this.type switch
+        {
+            CalculationType.Identity => value,
+            CalculationType.Gamma => MathF.Pow(value, this.gamma), // TODO: This could be optimized using a LUT. See SrgbCompanding
+            CalculationType.Lut => this.lutCalculator.Calculate(value),
+            _ => throw new InvalidOperationException("Invalid calculation type"),
+        };
+}

src/ImageSharp/ColorSpaces/Conversion/Implementation/Icc/Calculators/GrayTrcCalculator.cs

@@ -0,0 +1,19 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorSpaces.Conversion.Icc;
+
+internal class GrayTrcCalculator : IVector4Calculator
+{
+    private readonly TrcCalculator calculator;
+
+    public GrayTrcCalculator(IccTagDataEntry grayTrc, bool toPcs)
+        => this.calculator = new TrcCalculator(new IccTagDataEntry[] { grayTrc }, !toPcs);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Vector4 Calculate(Vector4 value) => this.calculator.Calculate(value);
+}

src/ImageSharp/ColorSpaces/Conversion/Implementation/Icc/Calculators/ISingleCalculator.cs

@@ -0,0 +1,17 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.ColorSpaces.Conversion.Icc;
+
+/// <summary>
+/// Represents an ICC calculator with a single floating point value and result
+/// </summary>
+internal interface ISingleCalculator
+{
+    /// <summary>
+    /// Calculates a result from the given value
+    /// </summary>
+    /// <param name="value">The input value</param>
+    /// <returns>The calculated result</returns>
+    float Calculate(float value);
+}

src/ImageSharp/ColorSpaces/Conversion/Implementation/Icc/Calculators/IVector4Calculator.cs

@@ -0,0 +1,19 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+
+namespace SixLabors.ImageSharp.ColorSpaces.Conversion.Icc;
+
+/// <summary>
+/// Represents an ICC calculator with <see cref="Vector4"/> values and results
+/// </summary>
+internal interface IVector4Calculator
+{
+    /// <summary>
+    /// Calculates a result from the given values
+    /// </summary>
+    /// <param name="value">The input values</param>
+    /// <returns>The calculated result</returns>
+    Vector4 Calculate(Vector4 value);
+}

src/ImageSharp/ColorSpaces/Conversion/Implementation/Icc/Calculators/LutABCalculator.CalculationType.cs

@@ -0,0 +1,18 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.ColorSpaces.Conversion.Icc;
+
+internal partial class LutABCalculator
+{
+    private enum CalculationType
+    {
+        AtoB = 1 << 3,
+        BtoA = 1 << 4,
+
+        SingleCurve = 1,
+        CurveMatrix = 2,
+        CurveClut = 3,
+        Full = 4,
+    }
+}