Color conversion with ICC profiles

src/ImageSharp/ColorProfiles/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.ColorProfiles.Icc.Calculators;
+
+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/ColorProfiles/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/ColorProfiles/Icc/Calculators/CurveCalculator.cs

@@ -0,0 +1,47 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+#nullable disable
+
+using SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+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/ColorProfiles/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.ColorProfiles.Icc.Calculators;
+
+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/ColorProfiles/Icc/Calculators/ISingleCalculator.cs

@@ -0,0 +1,17 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+
+/// <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/ColorProfiles/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.ColorProfiles.Icc.Calculators;
+
+/// <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/ColorProfiles/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,
+    }
+}

src/ImageSharp/ColorProfiles/Icc/Calculators/LutABCalculator.cs

@@ -0,0 +1,135 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+#nullable disable
+
+using System.Numerics;
+using SixLabors.ImageSharp.ColorProfiles.Icc.Calculators;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
+
+namespace SixLabors.ImageSharp.ColorSpaces.Conversion.Icc;
+
+internal partial class LutABCalculator : IVector4Calculator
+{
+    private CalculationType type;
+    private TrcCalculator curveACalculator;
+    private TrcCalculator curveBCalculator;
+    private TrcCalculator curveMCalculator;
+    private MatrixCalculator matrixCalculator;
+    private ClutCalculator clutCalculator;
+
+    public LutABCalculator(IccLutAToBTagDataEntry entry)
+    {
+        Guard.NotNull(entry, nameof(entry));
+        this.Init(entry.CurveA, entry.CurveB, entry.CurveM, entry.Matrix3x1, entry.Matrix3x3, entry.ClutValues);
+        this.type |= CalculationType.AtoB;
+    }
+
+    public LutABCalculator(IccLutBToATagDataEntry entry)
+    {
+        Guard.NotNull(entry, nameof(entry));
+        this.Init(entry.CurveA, entry.CurveB, entry.CurveM, entry.Matrix3x1, entry.Matrix3x3, entry.ClutValues);
+        this.type |= CalculationType.BtoA;
+    }
+
+    public Vector4 Calculate(Vector4 value)
+    {
+        switch (this.type)
+        {
+            case CalculationType.Full | CalculationType.AtoB:
+                value = this.curveACalculator.Calculate(value);
+                value = this.clutCalculator.Calculate(value);
+                value = this.curveMCalculator.Calculate(value);
+                value = this.matrixCalculator.Calculate(value);
+                return this.curveBCalculator.Calculate(value);
+
+            case CalculationType.Full | CalculationType.BtoA:
+                value = this.curveBCalculator.Calculate(value);
+                value = this.matrixCalculator.Calculate(value);
+                value = this.curveMCalculator.Calculate(value);
+                value = this.clutCalculator.Calculate(value);
+                return this.curveACalculator.Calculate(value);
+
+            case CalculationType.CurveClut | CalculationType.AtoB:
+                value = this.curveACalculator.Calculate(value);
+                value = this.clutCalculator.Calculate(value);
+                return this.curveBCalculator.Calculate(value);
+
+            case CalculationType.CurveClut | CalculationType.BtoA:
+                value = this.curveBCalculator.Calculate(value);
+                value = this.clutCalculator.Calculate(value);
+                return this.curveACalculator.Calculate(value);
+
+            case CalculationType.CurveMatrix | CalculationType.AtoB:
+                value = this.curveMCalculator.Calculate(value);
+                value = this.matrixCalculator.Calculate(value);
+                return this.curveBCalculator.Calculate(value);
+
+            case CalculationType.CurveMatrix | CalculationType.BtoA:
+                value = this.curveBCalculator.Calculate(value);
+                value = this.matrixCalculator.Calculate(value);
+                return this.curveMCalculator.Calculate(value);
+
+            case CalculationType.SingleCurve | CalculationType.AtoB:
+            case CalculationType.SingleCurve | CalculationType.BtoA:
+                return this.curveBCalculator.Calculate(value);
+
+            default:
+                throw new InvalidOperationException("Invalid calculation type");
+        }
+    }
+
+    private void Init(IccTagDataEntry[] curveA, IccTagDataEntry[] curveB, IccTagDataEntry[] curveM, Vector3? matrix3x1, Matrix4x4? matrix3x3, IccClut clut)
+    {
+        bool hasACurve = curveA != null;
+        bool hasBCurve = curveB != null;
+        bool hasMCurve = curveM != null;
+        bool hasMatrix = matrix3x1 != null && matrix3x3 != null;
+        bool hasClut = clut != null;
+
+        if (hasBCurve && hasMatrix && hasMCurve && hasClut && hasACurve)
+        {
+            this.type = CalculationType.Full;
+        }
+        else if (hasBCurve && hasClut && hasACurve)
+        {
+            this.type = CalculationType.CurveClut;
+        }
+        else if (hasBCurve && hasMatrix && hasMCurve)
+        {
+            this.type = CalculationType.CurveMatrix;
+        }
+        else if (hasBCurve)
+        {
+            this.type = CalculationType.SingleCurve;
+        }
+        else
+        {
+            throw new InvalidIccProfileException("AToB or BToA tag has an invalid configuration");
+        }
+
+        if (hasACurve)
+        {
+            this.curveACalculator = new TrcCalculator(curveA, false);
+        }
+
+        if (hasBCurve)
+        {
+            this.curveBCalculator = new TrcCalculator(curveB, false);
+        }
+
+        if (hasMCurve)
+        {
+            this.curveMCalculator = new TrcCalculator(curveM, false);
+        }
+
+        if (hasMatrix)
+        {
+            this.matrixCalculator = new MatrixCalculator(matrix3x3.Value, matrix3x1.Value);
+        }
+
+        if (hasClut)
+        {
+            this.clutCalculator = new ClutCalculator(clut);
+        }
+    }
+}