CieXyy tests

tests/ImageSharp.Tests/Colorspaces/Conversion/CieXyyAndHslConversionTests.cs

@@ -0,0 +1,80 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using SixLabors.ImageSharp.ColorSpaces;
+using SixLabors.ImageSharp.ColorSpaces.Conversion;
+using Xunit;
+
+namespace SixLabors.ImageSharp.Tests.Colorspaces.Conversion
+{
+    /// <summary>
+    /// Tests <see cref="CieXyy"/>-<see cref="Hsl"/> conversions.
+    /// </summary>
+    public class CieXyyAndHslConversionTests
+    {
+        private static readonly ApproximateColorSpaceComparer ColorSpaceComparer = new ApproximateColorSpaceComparer(.0002F);
+        private static readonly ColorSpaceConverter Converter = new ColorSpaceConverter();
+
+        /// <summary>
+        /// Tests conversion from <see cref="CieXyy"/> to <see cref="Hsl"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0)]
+        [InlineData(0.360555, 0.936901, 0.1001514, 120, 1, 0.211263)]
+        public void Convert_CieXyy_to_Hsl(float x, float y, float yl, float h, float s, float l)
+        {
+            // Arrange
+            var input = new CieXyy(x, y, yl);
+            var expected = new Hsl(h, s, l);
+
+            Span<CieXyy> inputSpan = new CieXyy[5];
+            inputSpan.Fill(input);
+
+            Span<Hsl> actualSpan = new Hsl[5];
+
+            // Act
+            var actual = Converter.ToHsl(input);
+            Converter.Convert(inputSpan, actualSpan, actualSpan.Length);
+
+            // Assert
+            Assert.Equal(expected, actual, ColorSpaceComparer);
+
+            for (int i = 0; i < actualSpan.Length; i++)
+            {
+                Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
+            }
+        }
+
+        /// <summary>
+        /// Tests conversion from <see cref="Hsl"/> to <see cref="CieXyy"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0)]
+        [InlineData(120, 1, 0.211263, 0.3, 0.6, 0.1067051)]
+        public void Convert_Hsl_to_CieXyy(float h, float s, float l, float x, float y, float yl)
+        {
+            // Arrange
+            var input = new Hsl(h, s, l);
+            var expected = new CieXyy(x, y, yl);
+
+            Span<Hsl> inputSpan = new Hsl[5];
+            inputSpan.Fill(input);
+
+            Span<CieXyy> actualSpan = new CieXyy[5];
+
+            // Act
+            var actual = Converter.ToCieXyy(input);
+            Converter.Convert(inputSpan, actualSpan, actualSpan.Length);
+
+            // Assert
+            Assert.Equal(expected, actual, ColorSpaceComparer);
+
+
+            for (int i = 0; i < actualSpan.Length; i++)
+            {
+                Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
+            }
+        }
+    }
+}

tests/ImageSharp.Tests/Colorspaces/Conversion/CieXyyAndHsvConversionTests.cs

@@ -0,0 +1,80 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using SixLabors.ImageSharp.ColorSpaces;
+using SixLabors.ImageSharp.ColorSpaces.Conversion;
+using Xunit;
+
+namespace SixLabors.ImageSharp.Tests.Colorspaces.Conversion
+{
+    /// <summary>
+    /// Tests <see cref="CieXyy"/>-<see cref="Hsv"/> conversions.
+    /// </summary>
+    public class CieXyyAndHsvConversionTests
+    {
+        private static readonly ApproximateColorSpaceComparer ColorSpaceComparer = new ApproximateColorSpaceComparer(.0002F);
+        private static readonly ColorSpaceConverter Converter = new ColorSpaceConverter();
+
+        /// <summary>
+        /// Tests conversion from <see cref="CieXyy"/> to <see cref="Hsv"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0)]
+        [InlineData(0.360555, 0.936901, 0.1001514, 120, 1, 0.4225259)]
+        public void Convert_CieXyy_to_Hsv(float x, float y, float yl, float h, float s, float v)
+        {
+            // Arrange
+            var input = new CieXyy(x, y, yl);
+            var expected = new Hsv(h, s, v);
+
+            Span<CieXyy> inputSpan = new CieXyy[5];
+            inputSpan.Fill(input);
+
+            Span<Hsv> actualSpan = new Hsv[5];
+
+            // Act
+            var actual = Converter.ToHsv(input);
+            Converter.Convert(inputSpan, actualSpan, actualSpan.Length);
+
+            // Assert
+            Assert.Equal(expected, actual, ColorSpaceComparer);
+
+            for (int i = 0; i < actualSpan.Length; i++)
+            {
+                Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
+            }
+        }
+
+        /// <summary>
+        /// Tests conversion from <see cref="Hsv"/> to <see cref="CieXyy"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0)]
+        [InlineData(120, 1, 0.4225259, 0.3, 0.6, 0.1067051)]
+        public void Convert_Hsv_to_CieXyy(float h, float s, float v, float x, float y, float yl)
+        {
+            // Arrange
+            var input = new Hsv(h, s, v);
+            var expected = new CieXyy(x, y, yl);
+
+            Span<Hsv> inputSpan = new Hsv[5];
+            inputSpan.Fill(input);
+
+            Span<CieXyy> actualSpan = new CieXyy[5];
+
+            // Act
+            var actual = Converter.ToCieXyy(input);
+            Converter.Convert(inputSpan, actualSpan, actualSpan.Length);
+
+            // Assert
+            Assert.Equal(expected, actual, ColorSpaceComparer);
+
+
+            for (int i = 0; i < actualSpan.Length; i++)
+            {
+                Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
+            }
+        }
+    }
+}

tests/ImageSharp.Tests/Colorspaces/Conversion/CieXyyAndHunterLabConversionTests.cs

@@ -0,0 +1,80 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using SixLabors.ImageSharp.ColorSpaces;
+using SixLabors.ImageSharp.ColorSpaces.Conversion;
+using Xunit;
+
+namespace SixLabors.ImageSharp.Tests.Colorspaces.Conversion
+{
+    /// <summary>
+    /// Tests <see cref="CieXyy"/>-<see cref="HunterLab"/> conversions.
+    /// </summary>
+    public class CieXyyAndHunterLabConversionTests
+    {
+        private static readonly ApproximateColorSpaceComparer ColorSpaceComparer = new ApproximateColorSpaceComparer(.0002F);
+        private static readonly ColorSpaceConverter Converter = new ColorSpaceConverter();
+
+        /// <summary>
+        /// Tests conversion from <see cref="CieXyy"/> to <see cref="HunterLab"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0)]
+        [InlineData(0.360555, 0.936901, 0.1001514, 31.46263, -32.81796, 28.64938)]
+        public void Convert_CieXyy_to_HunterLab(float x, float y, float yl, float l, float a, float b)
+        {
+            // Arrange
+            var input = new CieXyy(x, y, yl);
+            var expected = new HunterLab(l, a, b);
+
+            Span<CieXyy> inputSpan = new CieXyy[5];
+            inputSpan.Fill(input);
+
+            Span<HunterLab> actualSpan = new HunterLab[5];
+
+            // Act
+            var actual = Converter.ToHunterLab(input);
+            Converter.Convert(inputSpan, actualSpan, actualSpan.Length);
+
+            // Assert
+            Assert.Equal(expected, actual, ColorSpaceComparer);
+
+            for (int i = 0; i < actualSpan.Length; i++)
+            {
+                Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
+            }
+        }
+
+        /// <summary>
+        /// Tests conversion from <see cref="HunterLab"/> to <see cref="CieXyy"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0)]
+        [InlineData(31.46263, -32.81796, 28.64938, 0.3605552, 0.9369011, 0.1001514)]
+        public void Convert_HunterLab_to_CieXyy(float l, float a, float b, float x, float y, float yl)
+        {
+            // Arrange
+            var input = new HunterLab(l, a, b);
+            var expected = new CieXyy(x, y, yl);
+
+            Span<HunterLab> inputSpan = new HunterLab[5];
+            inputSpan.Fill(input);
+
+            Span<CieXyy> actualSpan = new CieXyy[5];
+
+            // Act
+            var actual = Converter.ToCieXyy(input);
+            Converter.Convert(inputSpan, actualSpan, actualSpan.Length);
+
+            // Assert
+            Assert.Equal(expected, actual, ColorSpaceComparer);
+
+
+            for (int i = 0; i < actualSpan.Length; i++)
+            {
+                Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
+            }
+        }
+    }
+}

tests/ImageSharp.Tests/Colorspaces/Conversion/CieXyyAndLinearRgbConversionTests.cs

@@ -0,0 +1,80 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using SixLabors.ImageSharp.ColorSpaces;
+using SixLabors.ImageSharp.ColorSpaces.Conversion;
+using Xunit;
+
+namespace SixLabors.ImageSharp.Tests.Colorspaces.Conversion
+{
+    /// <summary>
+    /// Tests <see cref="CieXyy"/>-<see cref="LinearRgb"/> conversions.
+    /// </summary>
+    public class CieXyyAndLinearRgbConversionTests
+    {
+        private static readonly ApproximateColorSpaceComparer ColorSpaceComparer = new ApproximateColorSpaceComparer(.0002F);
+        private static readonly ColorSpaceConverter Converter = new ColorSpaceConverter();
+
+        /// <summary>
+        /// Tests conversion from <see cref="CieXyy"/> to <see cref="LinearRgb"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0)]
+        [InlineData(0.360555, 0.936901, 0.1001514, 0, 0.1492062, 0)]
+        public void Convert_CieXyy_to_LinearRgb(float x, float y, float yl, float r, float g, float b)
+        {
+            // Arrange
+            var input = new CieXyy(x, y, yl);
+            var expected = new LinearRgb(r, g, b);
+
+            Span<CieXyy> inputSpan = new CieXyy[5];
+            inputSpan.Fill(input);
+
+            Span<LinearRgb> actualSpan = new LinearRgb[5];
+
+            // Act
+            var actual = Converter.ToLinearRgb(input);
+            Converter.Convert(inputSpan, actualSpan, actualSpan.Length);
+
+            // Assert
+            Assert.Equal(expected, actual, ColorSpaceComparer);
+
+            for (int i = 0; i < actualSpan.Length; i++)
+            {
+                Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
+            }
+        }
+
+        /// <summary>
+        /// Tests conversion from <see cref="LinearRgb"/> to <see cref="CieXyy"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0)]
+        [InlineData(0, 0.1492062, 0, 0.3, 0.6, 0.1067051)]
+        public void Convert_LinearRgb_to_CieXyy(float r, float g, float b, float x, float y, float yl)
+        {
+            // Arrange
+            var input = new LinearRgb(r, g, b);
+            var expected = new CieXyy(x, y, yl);
+
+            Span<LinearRgb> inputSpan = new LinearRgb[5];
+            inputSpan.Fill(input);
+
+            Span<CieXyy> actualSpan = new CieXyy[5];
+
+            // Act
+            var actual = Converter.ToCieXyy(input);
+            Converter.Convert(inputSpan, actualSpan, actualSpan.Length);
+
+            // Assert
+            Assert.Equal(expected, actual, ColorSpaceComparer);
+
+
+            for (int i = 0; i < actualSpan.Length; i++)
+            {
+                Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
+            }
+        }
+    }
+}

tests/ImageSharp.Tests/Colorspaces/Conversion/CieXyyAndLmsConversionTests.cs

@@ -0,0 +1,80 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using SixLabors.ImageSharp.ColorSpaces;
+using SixLabors.ImageSharp.ColorSpaces.Conversion;
+using Xunit;
+
+namespace SixLabors.ImageSharp.Tests.Colorspaces.Conversion
+{
+    /// <summary>
+    /// Tests <see cref="CieXyy"/>-<see cref="Lms"/> conversions.
+    /// </summary>
+    public class CieXyyAndLmsConversionTests
+    {
+        private static readonly ApproximateColorSpaceComparer ColorSpaceComparer = new ApproximateColorSpaceComparer(.0002F);
+        private static readonly ColorSpaceConverter Converter = new ColorSpaceConverter();
+
+        /// <summary>
+        /// Tests conversion from <see cref="CieXyy"/> to <see cref="Lms"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0)]
+        [InlineData(0.360555, 0.936901, 0.1001514, 0.06631134, 0.1415282, -0.03809926)]
+        public void Convert_CieXyy_to_Lms(float x, float y, float yl, float l, float m, float s)
+        {
+            // Arrange
+            var input = new CieXyy(x, y, yl);
+            var expected = new Lms(l, m, s);
+
+            Span<CieXyy> inputSpan = new CieXyy[5];
+            inputSpan.Fill(input);
+
+            Span<Lms> actualSpan = new Lms[5];
+
+            // Act
+            var actual = Converter.ToLms(input);
+            Converter.Convert(inputSpan, actualSpan, actualSpan.Length);
+
+            // Assert
+            Assert.Equal(expected, actual, ColorSpaceComparer);
+
+            for (int i = 0; i < actualSpan.Length; i++)
+            {
+                Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
+            }
+        }
+
+        /// <summary>
+        /// Tests conversion from <see cref="Lms"/> to <see cref="CieXyy"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0)]
+        [InlineData(0.06631134, 0.1415282, -0.03809926, 0.360555, 0.9369009, 0.1001514)]
+        public void Convert_Lms_to_CieXyy(float l, float m, float s, float x, float y, float yl)
+        {
+            // Arrange
+            var input = new Lms(l, m, s);
+            var expected = new CieXyy(x, y, yl);
+
+            Span<Lms> inputSpan = new Lms[5];
+            inputSpan.Fill(input);
+
+            Span<CieXyy> actualSpan = new CieXyy[5];
+
+            // Act
+            var actual = Converter.ToCieXyy(input);
+            Converter.Convert(inputSpan, actualSpan, actualSpan.Length);
+
+            // Assert
+            Assert.Equal(expected, actual, ColorSpaceComparer);
+
+
+            for (int i = 0; i < actualSpan.Length; i++)
+            {
+                Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
+            }
+        }
+    }
+}

tests/ImageSharp.Tests/Colorspaces/Conversion/CieXyyAndRgbConversionTests.cs

@@ -0,0 +1,80 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using SixLabors.ImageSharp.ColorSpaces;
+using SixLabors.ImageSharp.ColorSpaces.Conversion;
+using Xunit;
+
+namespace SixLabors.ImageSharp.Tests.Colorspaces.Conversion
+{
+    /// <summary>
+    /// Tests <see cref="CieXyy"/>-<see cref="Rgb"/> conversions.
+    /// </summary>
+    public class CieXyyAndRgbConversionTests
+    {
+        private static readonly ApproximateColorSpaceComparer ColorSpaceComparer = new ApproximateColorSpaceComparer(.0002F);
+        private static readonly ColorSpaceConverter Converter = new ColorSpaceConverter();
+
+        /// <summary>
+        /// Tests conversion from <see cref="CieXyy"/> to <see cref="Rgb"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0)]
+        [InlineData(0.360555, 0.936901, 0.1001514, 0, 0.4225259, 0)]
+        public void Convert_CieXyy_to_Rgb(float x, float y, float yl, float r, float g, float b)
+        {
+            // Arrange
+            var input = new CieXyy(x, y, yl);
+            var expected = new Rgb(r, g, b);
+
+            Span<CieXyy> inputSpan = new CieXyy[5];
+            inputSpan.Fill(input);
+
+            Span<Rgb> actualSpan = new Rgb[5];
+
+            // Act
+            var actual = Converter.ToRgb(input);
+            Converter.Convert(inputSpan, actualSpan, actualSpan.Length);
+
+            // Assert
+            Assert.Equal(expected, actual, ColorSpaceComparer);
+
+            for (int i = 0; i < actualSpan.Length; i++)
+            {
+                Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
+            }
+        }
+
+        /// <summary>
+        /// Tests conversion from <see cref="Rgb"/> to <see cref="CieXyy"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0)]
+        [InlineData(0, 0.4225259, 0, 0.3, 0.6, 0.1067051)]
+        public void Convert_Rgb_to_CieXyy(float r, float g, float b, float x, float y, float yl)
+        {
+            // Arrange
+            var input = new Rgb(r, g, b);
+            var expected = new CieXyy(x, y, yl);
+
+            Span<Rgb> inputSpan = new Rgb[5];
+            inputSpan.Fill(input);
+
+            Span<CieXyy> actualSpan = new CieXyy[5];
+
+            // Act
+            var actual = Converter.ToCieXyy(input);
+            Converter.Convert(inputSpan, actualSpan, actualSpan.Length);
+
+            // Assert
+            Assert.Equal(expected, actual, ColorSpaceComparer);
+
+
+            for (int i = 0; i < actualSpan.Length; i++)
+            {
+                Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
+            }
+        }
+    }
+}

tests/ImageSharp.Tests/Colorspaces/Conversion/CieXyyAndYCbCrConversionTests.cs

@@ -0,0 +1,80 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using SixLabors.ImageSharp.ColorSpaces;
+using SixLabors.ImageSharp.ColorSpaces.Conversion;
+using Xunit;
+
+namespace SixLabors.ImageSharp.Tests.Colorspaces.Conversion
+{
+    /// <summary>
+    /// Tests <see cref="CieXyy"/>-<see cref="YCbCr"/> conversions.
+    /// </summary>
+    public class CieXyyAndYCbCrConversionTests
+    {
+        private static readonly ApproximateColorSpaceComparer ColorSpaceComparer = new ApproximateColorSpaceComparer(.0002F);
+        private static readonly ColorSpaceConverter Converter = new ColorSpaceConverter();
+
+        /// <summary>
+        /// Tests conversion from <see cref="CieXyy"/> to <see cref="YCbCr"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 128, 128)]
+        [InlineData(0.360555, 0.936901, 0.1001514, 63.24579, 92.30826, 82.88884)]
+        public void Convert_CieXyy_to_YCbCr(float x, float y, float yl, float y2, float cb, float cr)
+        {
+            // Arrange
+            var input = new CieXyy(x, y, yl);
+            var expected = new YCbCr(y2, cb, cr);
+
+            Span<CieXyy> inputSpan = new CieXyy[5];
+            inputSpan.Fill(input);
+
+            Span<YCbCr> actualSpan = new YCbCr[5];
+
+            // Act
+            var actual = Converter.ToYCbCr(input);
+            Converter.Convert(inputSpan, actualSpan, actualSpan.Length);
+
+            // Assert
+            Assert.Equal(expected, actual, ColorSpaceComparer);
+
+            for (int i = 0; i < actualSpan.Length; i++)
+            {
+                Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
+            }
+        }
+
+        /// <summary>
+        /// Tests conversion from <see cref="YCbCr"/> to <see cref="CieXyy"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 128, 128, 0, 0, 0)]
+        [InlineData(63.24579, 92.30826, 82.88884, 0.3, 0.6, 0.1072441)]
+        public void Convert_YCbCr_to_CieXyy(float y2, float cb, float cr, float x, float y, float yl)
+        {
+            // Arrange
+            var input = new YCbCr(y2, cb, cr);
+            var expected = new CieXyy(x, y, yl);
+
+            Span<YCbCr> inputSpan = new YCbCr[5];
+            inputSpan.Fill(input);
+
+            Span<CieXyy> actualSpan = new CieXyy[5];
+
+            // Act
+            var actual = Converter.ToCieXyy(input);
+            Converter.Convert(inputSpan, actualSpan, actualSpan.Length);
+
+            // Assert
+            Assert.Equal(expected, actual, ColorSpaceComparer);
+
+
+            for (int i = 0; i < actualSpan.Length; i++)
+            {
+                Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
+            }
+        }
+    }
+}