All tests now pass!

src/ImageSharp/Colors/Spaces/Conversion/Implementation/Lms/CieXyzAndLmsConverter.cs

@@ -40,7 +40,7 @@ namespace ImageSharp.Colors.Spaces.Conversion.Implementation.Lms
         /// </param>
         public CieXyzAndLmsConverter(Matrix4x4 transformationMatrix)
         {
-            this.TransformationMatrix = Matrix4x4.Transpose(transformationMatrix);
+            this.TransformationMatrix = transformationMatrix;
         }
 
         /// <summary>

src/ImageSharp/Colors/Spaces/Conversion/Implementation/Lms/LmsAdaptationMatrix.cs

@@ -17,7 +17,7 @@ namespace ImageSharp.Colors.Spaces.Conversion.Implementation.Lms
     /// Two New von Kries Based Chromatic Adaptation Transforms Found by Numerical Optimization
     /// S. Bianco, R. Schettini
     /// DISCo, Department of Informatics, Systems and Communication, University of Milan-Bicocca, viale Sarca 336, 20126 Milan, Italy
-    /// http://www.ivl.disco.unimib.it/papers2003/CRA-CAT.pdf
+    /// https://web.stanford.edu/~sujason/ColorBalancing/Papers/Two%20New%20von%20Kries%20Based%20Chromatic%20Adaptation.pdf
     /// </remarks>
     public static class LmsAdaptationMatrix
     {
@@ -25,77 +25,77 @@ namespace ImageSharp.Colors.Spaces.Conversion.Implementation.Lms
         /// Von Kries chromatic adaptation transform matrix (Hunt-Pointer-Estevez adjusted for D65)
         /// </summary>
         public static readonly Matrix4x4 VonKriesHPEAdjusted
-            = new Matrix4x4
+            = Matrix4x4.Transpose(new Matrix4x4
             {
                 M11 = 0.40024F, M12 = 0.7076F,  M13 = -0.08081F,
                 M21 = -0.2263F, M22 = 1.16532F, M23 = 0.0457F,
                 M31 = 0,        M32 = 0,        M33 = 0.91822F,
                 M44 = 1F // Important for inverse transforms.
-            };
+            });
 
         /// <summary>
         /// Von Kries chromatic adaptation transform matrix (Hunt-Pointer-Estevez for equal energy)
         /// </summary>
         public static readonly Matrix4x4 VonKriesHPE
-            = new Matrix4x4
+            = Matrix4x4.Transpose(new Matrix4x4
             {
                 M11 = 0.3897F,  M12 = 0.6890F, M13 = -0.0787F,
                 M21 = -0.2298F, M22 = 1.1834F, M23 = 0.0464F,
                 M31 = 0,        M32 = 0,       M33 = 1F,
                 M44 = 1F
-            };
+            });
 
         /// <summary>
         /// XYZ scaling chromatic adaptation transform matrix
         /// </summary>
-        public static readonly Matrix4x4 XYZScaling = Matrix4x4.Identity;
+        public static readonly Matrix4x4 XYZScaling = Matrix4x4.Transpose(Matrix4x4.Identity);
 
         /// <summary>
         /// Bradford chromatic adaptation transform matrix (used in CMCCAT97)
         /// </summary>
         public static readonly Matrix4x4 Bradford
-            = new Matrix4x4
+            = Matrix4x4.Transpose(new Matrix4x4
             {
                 M11 = 0.8951F,  M12 = 0.2664F,  M13 = -0.1614F,
                 M21 = -0.7502F, M22 = 1.7135F,  M23 = 0.0367F,
                 M31 = 0.0389F,  M32 = -0.0685F, M33 = 1.0296F,
                 M44 = 1F
-            };
+            });
 
         /// <summary>
         /// Spectral sharpening and the Bradford transform
         /// </summary>
         public static readonly Matrix4x4 BradfordSharp
-            = new Matrix4x4
+            = Matrix4x4.Transpose(new Matrix4x4
              {
                  M11 = 1.2694F,  M12 = -0.0988F,  M13 = -0.1706F,
                  M21 = -0.8364F, M22 = 1.8006F,  M23 = 0.0357F,
                  M31 = 0.0297F,  M32 = -0.0315F, M33 = 1.0018F,
                  M44 = 1F
-             };
+             });
 
         /// <summary>
         /// CMCCAT2000 (fitted from all available color data sets)
         /// </summary>
         public static readonly Matrix4x4 CMCCAT2000
-            = new Matrix4x4
+            = Matrix4x4.Transpose(new Matrix4x4
              {
                  M11 = 0.7982F,  M12 = 0.3389F, M13 = -0.1371F,
                  M21 = -0.5918F, M22 = 1.5512F, M23 = 0.0406F,
                  M31 = 0.0008F,  M32 = 0.239F,  M33 = 0.9753F,
                  M44 = 1F
-             };
+             });
 
         /// <summary>
         /// CAT02 (optimized for minimizing CIELAB differences)
         /// </summary>
         public static readonly Matrix4x4 CAT02
-            = new Matrix4x4
+            = Matrix4x4.Transpose(new Matrix4x4
              {
                  M11 = 0.7328F,  M12 = 0.4296F, M13 = -0.1624F,
                  M21 = -0.7036F, M22 = 1.6975F, M23 = 0.0061F,
                  M31 = 0.0030F,  M32 = 0.0136F,  M33 = 0.9834F,
                  M44 = 1F
-             };
+             });
     }
 }

src/ImageSharp/Colors/Spaces/Conversion/Implementation/Rgb/LinearRgbAndCieXyzConverterBase.cs

@@ -55,7 +55,8 @@ namespace ImageSharp.Colors.Spaces.Conversion.Implementation.Rgb
 
             Vector3 vector = Vector3.Transform(workingSpace.WhitePoint.Vector, inverseXyzMatrix);
 
-            // TODO: Is there a built in method for this?
+            // Use transposed Rows/Coloumns
+            // TODO: Is there a built in method for this multiplication?
             return new Matrix4x4
             {
                 M11 = vector.X * mXr, M21 = vector.Y * mXg, M31 = vector.Z * mXb,

tests/ImageSharp.Tests/Colors/Colorspaces/CieXyzAndCieLabConversionTest.cs

@@ -3,7 +3,6 @@
     using System.Collections.Generic;
     using ImageSharp.Colors.Spaces;
     using ImageSharp.Colors.Spaces.Conversion;
-    using ImageSharp.Tests.TestUtilities;
 
     using Xunit;
 
@@ -40,9 +39,9 @@
             CieXyz output = converter.ToCieXyz(input);
 
             // Assert
-            Assert.Equal(output.X, x, FloatRoundingComparer);
-            Assert.Equal(output.Y, y, FloatRoundingComparer);
-            Assert.Equal(output.Z, z, FloatRoundingComparer);
+            Assert.Equal(x, output.X, FloatRoundingComparer);
+            Assert.Equal(y, output.Y, FloatRoundingComparer);
+            Assert.Equal(z, output.Z, FloatRoundingComparer);
         }
 
         /// <summary>
@@ -65,9 +64,9 @@
             CieLab output = converter.ToCieLab(input);
 
             // Assert
-            Assert.Equal(output.L, l, FloatRoundingComparer);
-            Assert.Equal(output.A, a, FloatRoundingComparer);
-            Assert.Equal(output.B, b, FloatRoundingComparer);
+            Assert.Equal(l, output.L, FloatRoundingComparer);
+            Assert.Equal(a, output.A, FloatRoundingComparer);
+            Assert.Equal(b, output.B, FloatRoundingComparer);
         }
     }
 }

tests/ImageSharp.Tests/Colors/Colorspaces/CieXyzAndHunterLabConversionTest.cs

@@ -15,10 +15,10 @@
     /// </remarks>
     public class CieXyzAndHunterLabConversionTest
     {
-        private static readonly IEqualityComparer<float> FloatComparer = new ApproximateFloatComparer(4);
+        private static readonly IEqualityComparer<float> FloatRoundingComparer = new FloatRoundingComparer(4);
 
         /// <summary>
-        /// Tests conversion from <see cref="CieLab"/> to <see cref="CieXyz"/> (<see cref="Illuminants.C"/>).
+        /// Tests conversion from <see cref="HunterLab"/> to <see cref="CieXyz"/> (<see cref="Illuminants.C"/>).
         /// </summary>
         [Theory]
         [InlineData(0, 0, 0, 0, 0, 0)]
@@ -33,13 +33,13 @@
             CieXyz output = converter.ToCieXyz(input);
 
             // Assert
-            Assert.Equal(output.X, x, FloatComparer);
-            Assert.Equal(output.Y, y, FloatComparer);
-            Assert.Equal(output.Z, z, FloatComparer);
+            Assert.Equal(x, output.X, FloatRoundingComparer);
+            Assert.Equal(y, output.Y, FloatRoundingComparer);
+            Assert.Equal(z, output.Z, FloatRoundingComparer);
         }
 
         /// <summary>
-        /// Tests conversion from <see cref="CieLab"/> to <see cref="CieXyz"/> (<see cref="Illuminants.D65"/>).
+        /// Tests conversion from <see cref="HunterLab"/> to <see cref="CieXyz"/> (<see cref="Illuminants.D65"/>).
         /// </summary>
         [Theory]
         [InlineData(0, 0, 0, 0, 0, 0)]
@@ -54,17 +54,17 @@
             CieXyz output = converter.ToCieXyz(input);
 
             // Assert
-            Assert.Equal(output.X, x, FloatComparer);
-            Assert.Equal(output.Y, y, FloatComparer);
-            Assert.Equal(output.Z, z, FloatComparer);
+            Assert.Equal(x, output.X, FloatRoundingComparer);
+            Assert.Equal(y, output.Y, FloatRoundingComparer);
+            Assert.Equal(z, output.Z, FloatRoundingComparer);
         }
 
         /// <summary>
-        /// Tests conversion from <see cref="CieXyz"/> (<see cref="Illuminants.D65"/>) to <see cref="CieLab"/>.
+        /// Tests conversion from <see cref="CieXyz"/> (<see cref="Illuminants.D65"/>) to <see cref="HunterLab"/>.
         /// </summary>
         [Theory]
         [InlineData(0, 0, 0, 0, 0, 0)]
-        [InlineData(0.95047, 1, 1.08883, 100, 0, 0)] // D65 white point is HunerLab 100, 0, 0 (adaptation to C performed)
+        [InlineData(0.95047, 1, 1.08883, 100, 0, 0)] // D65 white point is HunterLab 100, 0, 0 (adaptation to C performed)
         public void Convert_XYZ_D65_to_HunterLab(float x, float y, float z, float l, float a, float b)
         {
             // Arrange
@@ -75,9 +75,9 @@
             HunterLab output = converter.ToHunterLab(input);
 
             // Assert
-            Assert.Equal(output.L, l, FloatComparer);
-            Assert.Equal(output.A, a, FloatComparer);
-            Assert.Equal(output.B, b, FloatComparer);
+            Assert.Equal(l, output.L, FloatRoundingComparer);
+            Assert.Equal(a, output.A, FloatRoundingComparer);
+            Assert.Equal(b, output.B, FloatRoundingComparer);
         }
     }
 }

tests/ImageSharp.Tests/Colors/Colorspaces/CieXyzAndLmsConversionTest.cs

@@ -14,7 +14,7 @@
     /// </remarks>
     public class CieXyzAndLmsConversionTest
     {
-        private static readonly IEqualityComparer<float> FloatComparer = new ApproximateFloatComparer(6);
+        private static readonly IEqualityComparer<float> FloatRoundingComparer = new FloatRoundingComparer(5);
 
         /// <summary>
         /// Tests conversion from <see cref="CieXyz"/> (<see cref="Illuminants.D65"/>) to <see cref="Lms"/>.
@@ -29,16 +29,16 @@
         public void Convert_Lms_to_CieXyz(float l, float m, float s, float x, float y, float z)
         {
             // Arrange
-            Lms input = new Lms(x, y, z);
+            Lms input = new Lms(l, m, s);
             ColorSpaceConverter converter = new ColorSpaceConverter();
 
             // Act
             CieXyz output = converter.ToCieXyz(input);
 
             // Assert
-            Assert.Equal(output.X, l, FloatComparer);
-            Assert.Equal(output.Y, m, FloatComparer);
-            Assert.Equal(output.Z, s, FloatComparer);
+            Assert.Equal(x, output.X, FloatRoundingComparer);
+            Assert.Equal(y, output.Y, FloatRoundingComparer);
+            Assert.Equal(z, output.Z, FloatRoundingComparer);
         }
 
         /// <summary>
@@ -61,9 +61,9 @@
             Lms output = converter.ToLms(input);
 
             // Assert
-            Assert.Equal(output.L, l, FloatComparer);
-            Assert.Equal(output.M, m, FloatComparer);
-            Assert.Equal(output.S, s, FloatComparer);
+            Assert.Equal(l, output.L, FloatRoundingComparer);
+            Assert.Equal(m, output.M, FloatRoundingComparer);
+            Assert.Equal(s, output.S, FloatRoundingComparer);
         }
     }
 }

tests/ImageSharp.Tests/Colors/Colorspaces/ColorConverterAdaptTest.cs

@@ -10,7 +10,7 @@ namespace ImageSharp.Tests
 
     public class ColorConverterAdaptTest
     {
-        private static readonly IEqualityComparer<float> FloatComparer = new ApproximateFloatComparer(4);
+        private static readonly IEqualityComparer<float> FloatRoundingComparer = new FloatRoundingComparer(3);
 
         [Theory]
         [InlineData(0, 0, 0, 0, 0, 0)]
@@ -28,9 +28,9 @@ namespace ImageSharp.Tests
 
             // Assert
             Assert.Equal(expectedOutput.WorkingSpace, output.WorkingSpace);
-            Assert.Equal(output.R, expectedOutput.R, FloatComparer);
-            Assert.Equal(output.G, expectedOutput.G, FloatComparer);
-            Assert.Equal(output.B, expectedOutput.B, FloatComparer);
+            Assert.Equal(expectedOutput.R, output.R, FloatRoundingComparer);
+            Assert.Equal(expectedOutput.G, output.G, FloatRoundingComparer);
+            Assert.Equal(expectedOutput.B, output.B, FloatRoundingComparer);
         }
 
         [Theory]
@@ -49,9 +49,9 @@ namespace ImageSharp.Tests
 
             // Assert
             Assert.Equal(expectedOutput.WorkingSpace, output.WorkingSpace);
-            Assert.Equal(output.R, expectedOutput.R, FloatComparer);
-            Assert.Equal(output.G, expectedOutput.G, FloatComparer);
-            Assert.Equal(output.B, expectedOutput.B, FloatComparer);
+            Assert.Equal(expectedOutput.R, output.R, FloatRoundingComparer);
+            Assert.Equal(expectedOutput.G, output.G, FloatRoundingComparer);
+            Assert.Equal(expectedOutput.B, output.B, FloatRoundingComparer);
         }
 
         [Theory]
@@ -68,9 +68,9 @@ namespace ImageSharp.Tests
             CieLab output = converter.Adapt(input);
 
             // Assert
-            Assert.Equal(output.L, expectedOutput.L, FloatComparer);
-            Assert.Equal(output.A, expectedOutput.A, FloatComparer);
-            Assert.Equal(output.B, expectedOutput.B, FloatComparer);
+            Assert.Equal(expectedOutput.L, output.L, FloatRoundingComparer);
+            Assert.Equal(expectedOutput.A, output.A, FloatRoundingComparer);
+            Assert.Equal(expectedOutput.B, output.B, FloatRoundingComparer);
         }
 
         [Theory]
@@ -90,9 +90,9 @@ namespace ImageSharp.Tests
             CieXyz output = converter.Adapt(input, Illuminants.D65);
 
             // Assert
-            Assert.Equal(output.X, expectedOutput.X, FloatComparer);
-            Assert.Equal(output.Y, expectedOutput.Y, FloatComparer);
-            Assert.Equal(output.Z, expectedOutput.Z, FloatComparer);
+            Assert.Equal(expectedOutput.X, output.X, FloatRoundingComparer);
+            Assert.Equal(expectedOutput.Y, output.Y, FloatRoundingComparer);
+            Assert.Equal(expectedOutput.Z, output.Z, FloatRoundingComparer);
         }
 
         [Theory]
@@ -113,9 +113,9 @@ namespace ImageSharp.Tests
             CieXyz output = converter.Adapt(input, Illuminants.D65);
 
             // Assert
-            Assert.Equal(output.X, expectedOutput.X, FloatComparer);
-            Assert.Equal(output.Y, expectedOutput.Y, FloatComparer);
-            Assert.Equal(output.Z, expectedOutput.Z, FloatComparer);
+            Assert.Equal(expectedOutput.X, output.X, FloatRoundingComparer);
+            Assert.Equal(expectedOutput.Y, output.Y, FloatRoundingComparer);
+            Assert.Equal(expectedOutput.Z, output.Z, FloatRoundingComparer);
         }
 
         [Theory]
@@ -136,9 +136,9 @@ namespace ImageSharp.Tests
             CieXyz output = converter.Adapt(input, Illuminants.D65);
 
             // Assert
-            Assert.Equal(output.X, expectedOutput.X, FloatComparer);
-            Assert.Equal(output.Y, expectedOutput.Y, FloatComparer);
-            Assert.Equal(output.Z, expectedOutput.Z, FloatComparer);
+            Assert.Equal(expectedOutput.X, output.X, FloatRoundingComparer);
+            Assert.Equal(expectedOutput.Y, output.Y, FloatRoundingComparer);
+            Assert.Equal(expectedOutput.Z, output.Z, FloatRoundingComparer);
         }
     }
 }

tests/ImageSharp.Tests/Colors/Colorspaces/RgbAndCieXyzConversionTest.cs

@@ -3,7 +3,6 @@
     using System.Collections.Generic;
     using ImageSharp.Colors.Spaces;
     using ImageSharp.Colors.Spaces.Conversion;
-    using ImageSharp.Tests.TestUtilities;
 
     using Xunit;
 
@@ -16,7 +15,7 @@
     /// </remarks>
     public class RgbAndCieXyzConversionTest
     {
-        private static readonly IEqualityComparer<float> FloatComparerPrecision = new FloatRoundingComparer(6);
+        private static readonly IEqualityComparer<float> FloatRoundingComparer = new FloatRoundingComparer(6);
 
         /// <summary>
         /// Tests conversion from <see cref="CieXyz"/> (<see cref="Illuminants.D50"/>)
@@ -40,9 +39,9 @@
 
             // Assert
             Assert.Equal(output.WorkingSpace, Rgb.DefaultWorkingSpace); // TODO: Change Assert.Equal to the correct order, first the expected, then the current value
-            Assert.Equal(output.R, r, FloatComparerPrecision);
-            Assert.Equal(output.G, g, FloatComparerPrecision);
-            Assert.Equal(output.B, b, FloatComparerPrecision);
+            Assert.Equal(output.R, r, FloatRoundingComparer);
+            Assert.Equal(output.G, g, FloatRoundingComparer);
+            Assert.Equal(output.B, b, FloatRoundingComparer);
         }
 
         /// <summary>
@@ -68,9 +67,9 @@
 
             // Assert
             Assert.Equal(output.WorkingSpace, Rgb.DefaultWorkingSpace);
-            Assert.Equal(output.R, r, FloatComparerPrecision);
-            Assert.Equal(output.G, g, FloatComparerPrecision);
-            Assert.Equal(output.B, b, FloatComparerPrecision);
+            Assert.Equal(output.R, r, FloatRoundingComparer);
+            Assert.Equal(output.G, g, FloatRoundingComparer);
+            Assert.Equal(output.B, b, FloatRoundingComparer);
         }
 
         /// <summary>
@@ -94,9 +93,9 @@
             CieXyz output = converter.ToCieXyz(input);
 
             // Assert
-            Assert.Equal(output.X, x, FloatComparerPrecision);
-            Assert.Equal(output.Y, y, FloatComparerPrecision);
-            Assert.Equal(output.Z, z, FloatComparerPrecision);
+            Assert.Equal(output.X, x, FloatRoundingComparer);
+            Assert.Equal(output.Y, y, FloatRoundingComparer);
+            Assert.Equal(output.Z, z, FloatRoundingComparer);
         }
 
         /// <summary>
@@ -120,9 +119,9 @@
             CieXyz output = converter.ToCieXyz(input);
 
             // Assert
-            Assert.Equal(output.X, x, FloatComparerPrecision);
-            Assert.Equal(output.Y, y, FloatComparerPrecision);
-            Assert.Equal(output.Z, z, FloatComparerPrecision);
+            Assert.Equal(output.X, x, FloatRoundingComparer);
+            Assert.Equal(output.Y, y, FloatRoundingComparer);
+            Assert.Equal(output.Z, z, FloatRoundingComparer);
         }
     }
 }