CieLuv tests

src/ImageSharp/ColorSpaces/CieLch.cs

@@ -13,7 +13,7 @@ namespace SixLabors.ImageSharp.ColorSpaces
     /// </summary>
     public readonly struct CieLch : IEquatable<CieLch>
     {
-        private static readonly Vector3 Min = Vector3.Zero;
+        private static readonly Vector3 Min = new Vector3(0, -200, 0);
         private static readonly Vector3 Max = new Vector3(100, 200, 360);
 
         /// <summary>

src/ImageSharp/ColorSpaces/CieLchuv.cs

@@ -13,7 +13,7 @@ namespace SixLabors.ImageSharp.ColorSpaces
     /// </summary>
     public readonly struct CieLchuv : IEquatable<CieLchuv>
     {
-        private static readonly Vector3 Min = Vector3.Zero;
+        private static readonly Vector3 Min = new Vector3(0, -200, 0);
         private static readonly Vector3 Max = new Vector3(100, 200, 360);
 
         /// <summary>

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

@@ -0,0 +1,79 @@
+// 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="CieLch"/>-<see cref="CieXyy"/> conversions.
+    /// </summary>
+    public class CieLchAndCieXyyConversionTests
+    {
+        private static readonly ApproximateColorSpaceComparer ColorSpaceComparer = new ApproximateColorSpaceComparer(.0002F);
+        private static readonly ColorSpaceConverter Converter = new ColorSpaceConverter();
+
+        /// <summary>
+        /// Tests conversion from <see cref="CieLch"/> to <see cref="CieXyy"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0)]
+        [InlineData(36.0555, 103.6901, 10.01514, 0.6529307, 0.2147411, 0.08447381)]
+        public void Convert_CieLch_to_CieXyy(float l, float c, float h, float x, float y, float yl)
+        {
+            // Arrange
+            var input = new CieLch(l, c, h);
+            var expected = new CieXyy(x, y, yl);
+
+            Span<CieLch> inputSpan = new CieLch[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);
+            }
+        }
+
+        /// <summary>
+        /// Tests conversion from <see cref="CieXyy"/> to <see cref="CieLch"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0.6529307, 0.2147411, 0.08447381, 36.05552, 103.6901, 10.01515)]
+        public void Convert_CieXyy_to_CieLch(float x, float y, float yl, float l, float c, float h)
+        {
+            // Arrange
+            var input = new CieXyy(x, y, yl);
+            var expected = new CieLch(l, c, h);
+
+            Span<CieXyy> inputSpan = new CieXyy[5];
+            inputSpan.Fill(input);
+
+            Span<CieLch> actualSpan = new CieLch[5];
+
+            // Act
+            var actual = Converter.ToCieLch(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/CieLchuvAndCieLchConversionTests.cs

@@ -0,0 +1,78 @@
+// 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="CieLchuv"/>-<see cref="CieLch"/> conversions.
+    /// </summary>
+    public class CieLchuvAndCieLchConversionTests
+    {
+        private static readonly ApproximateColorSpaceComparer ColorSpaceComparer = new ApproximateColorSpaceComparer(.0002F);
+        private static readonly ColorSpaceConverter Converter = new ColorSpaceConverter();
+
+        /// <summary>
+        /// Tests conversion from <see cref="CieLch"/> to <see cref="CieLchuv"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0)]
+        [InlineData(36.73742, 64.79149, 30.1786, 36.0555, 103.6901, 10.01513)]
+        public void Convert_CieLch_to_CieLchuv(float l2, float c2, float h2, float l, float c, float h)
+        {
+            // Arrange
+            var input = new CieLch(l2, c2, h2);
+            var expected = new CieLchuv(l, c, h);
+
+            Span<CieLch> inputSpan = new CieLch[5];
+            inputSpan.Fill(input);
+
+            Span<CieLchuv> actualSpan = new CieLchuv[5];
+
+            // Act
+            var actual = Converter.ToCieLchuv(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="CieLchuv"/> to <see cref="CieLch"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(36.0555, 103.6901, 10.01514, 36.73742, 64.79149, 30.1786)]
+        public void Convert_CieLchuv_to_CieLch(float l, float c, float h, float l2, float c2, float h2)
+        {
+            // Arrange
+            var input = new CieLchuv(l, c, h);
+            var expected = new CieLch(l2, c2, h2);
+
+            Span<CieLchuv> inputSpan = new CieLchuv[5];
+            inputSpan.Fill(input);
+
+            Span<CieLch> actualSpan = new CieLch[5];
+
+            // Act
+            var actual = Converter.ToCieLch(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/CieLuvAndCieLchuvConversionTests.cs → tests/ImageSharp.Tests/Colorspaces/Conversion/CieLchuvAndCieLuvConversionTests.cs

@@ -15,7 +15,7 @@ namespace SixLabors.ImageSharp.Tests.Colorspaces.Conversion
     /// Test data generated using:
     /// <see href="http://www.brucelindbloom.com/index.html?ColorCalculator.html"/>
     /// </remarks>
-    public class CieLuvAndCieLchuvConversionTests
+    public class CieLchuvAndCieLuvConversionTests
     {
         private static readonly ApproximateColorSpaceComparer ColorSpaceComparer = new ApproximateColorSpaceComparer(.0001F);
         private static readonly ColorSpaceConverter Converter = new ColorSpaceConverter();
@@ -32,7 +32,7 @@ namespace SixLabors.ImageSharp.Tests.Colorspaces.Conversion
         [InlineData(10, 36.0555, 123.6901, 10, -20, 30)]
         [InlineData(10, 36.0555, 303.6901, 10, 20, -30)]
         [InlineData(10, 36.0555, 236.3099, 10, -20, -30)]
-        public void Convert_Lchuv_to_Luv(float l, float c, float h, float l2, float u, float v)
+        public void Convert_CieLchuv_to_CieLuv(float l, float c, float h, float l2, float u, float v)
         {
             // Arrange
             var input = new CieLchuv(l, c, h);
@@ -69,7 +69,7 @@ namespace SixLabors.ImageSharp.Tests.Colorspaces.Conversion
         [InlineData(10, 20, -30, 10, 36.0555, 303.6901)]
         [InlineData(10, -20, -30, 10, 36.0555, 236.3099)]
         [InlineData(37.3511, 24.1720, 16.0684, 37.3511, 29.0255, 33.6141)]
-        public void Convert_Luv_to_LCHuv(float l, float u, float v, float l2, float c, float h)
+        public void Convert_CieLuv_to_CieLchuv(float l, float u, float v, float l2, float c, float h)
         {
             // Arrange
             var input = new CieLuv(l, u, v);

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

@@ -0,0 +1,79 @@
+// 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="CieLchuv"/>-<see cref="Cmyk"/> conversions.
+    /// </summary>
+    public class CieLchuvAndCmykConversionTests
+    {
+        private static readonly ApproximateColorSpaceComparer ColorSpaceComparer = new ApproximateColorSpaceComparer(.0002F);
+        private static readonly ColorSpaceConverter Converter = new ColorSpaceConverter();
+
+        /// <summary>
+        /// Tests conversion from <see cref="Cmyk"/> to <see cref="CieLchuv"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 1, 0, 0, 0)]
+        [InlineData(0, 0.8576171, 0.7693201, 0.3440427, 36.0555, 103.6901, 10.01514)]
+        public void Convert_Cmyk_to_CieLchuv(float c2, float m, float y, float k, float l, float c, float h)
+        {
+            // Arrange
+            var input = new Cmyk(c2, m, y, k);
+            var expected = new CieLchuv(l, c, h);
+
+            Span<Cmyk> inputSpan = new Cmyk[5];
+            inputSpan.Fill(input);
+
+            Span<CieLchuv> actualSpan = new CieLchuv[5];
+
+            // Act
+            var actual = Converter.ToCieLchuv(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="CieLchuv"/> to <see cref="Cmyk"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0, 1)]
+        [InlineData(36.0555, 103.6901, 10.01514, 0, 0.8576171, 0.7693201, 0.3440427)]
+        public void Convert_CieLchuv_to_Cmyk(float l, float c, float h, float c2, float m, float y, float k)
+        {
+            // Arrange
+            var input = new CieLchuv(l, c, h);
+            var expected = new Cmyk(c2, m, y, k);
+
+            Span<CieLchuv> inputSpan = new CieLchuv[5];
+            inputSpan.Fill(input);
+
+            Span<Cmyk> actualSpan = new Cmyk[5];
+
+            // Act
+            var actual = Converter.ToCmyk(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/CieLuvAndCieXyyConversionTests.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="CieLuv"/>-<see cref="CieXyy"/> conversions.
+    /// </summary>
+    public class CieLuvAndCieXyyConversionTests
+    {
+        private static readonly ApproximateColorSpaceComparer ColorSpaceComparer = new ApproximateColorSpaceComparer(.0002F);
+        private static readonly ColorSpaceConverter Converter = new ColorSpaceConverter();
+
+        /// <summary>
+        /// Tests conversion from <see cref="CieLuv"/> to <see cref="CieXyy"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0)]
+        [InlineData(36.0555, 103.6901, 10.01514, 0.5646762, 0.2932749, 0.09037033)]
+        public void Convert_CieLuv_to_CieXyy(float l, float u, float v, float x, float y, float yl)
+        {
+            // Arrange
+            var input = new CieLuv(l, u, v);
+            var expected = new CieXyy(x, y, yl);
+
+            Span<CieLuv> inputSpan = new CieLuv[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);
+            }
+        }
+
+        /// <summary>
+        /// Tests conversion from <see cref="CieXyy"/> to <see cref="CieLuv"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0)]
+        [InlineData(0.5646762, 0.2932749, 0.09037033, 36.0555, 103.6901, 10.01514)]
+        public void Convert_CieXyy_to_CieLuv(float x, float y, float yl, float l, float u, float v)
+        {
+            // Arrange
+            var input = new CieXyy(x, y, yl);
+            var expected = new CieLuv(l, u, v);
+
+            Span<CieXyy> inputSpan = new CieXyy[5];
+            inputSpan.Fill(input);
+
+            Span<CieLuv> actualSpan = new CieLuv[5];
+
+            // Act
+            var actual = Converter.ToCieLuv(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/CieLuvAndHslConversionTests.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="CieLuv"/>-<see cref="Hsl"/> conversions.
+    /// </summary>
+    public class CieLuvAndHslConversionTests
+    {
+        private static readonly ApproximateColorSpaceComparer ColorSpaceComparer = new ApproximateColorSpaceComparer(.0002F);
+        private static readonly ColorSpaceConverter Converter = new ColorSpaceConverter();
+
+        /// <summary>
+        /// Tests conversion from <see cref="CieLuv"/> to <see cref="Hsl"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0)]
+        [InlineData(36.0555, 93.6901, 10.01514, 347.3767, 0.7115612, 0.3765343)]
+        public void Convert_CieLuv_to_Hsl(float l, float u, float v, float h, float s, float l2)
+        {
+            // Arrange
+            var input = new CieLuv(l, u, v);
+            var expected = new Hsl(h, s, l2);
+
+            Span<CieLuv> inputSpan = new CieLuv[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="CieLuv"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0)]
+        [InlineData(347.3767, 0.7115612, 0.3765343, 36.0555, 93.69012, 10.01514)]
+        public void Convert_Hsl_to_CieLuv(float h, float s, float l2, float l, float u, float v)
+        {
+            // Arrange
+            var input = new Hsl(h, s, l2);
+            var expected = new CieLuv(l, u, v);
+
+            Span<Hsl> inputSpan = new Hsl[5];
+            inputSpan.Fill(input);
+
+            Span<CieLuv> actualSpan = new CieLuv[5];
+
+            // Act
+            var actual = Converter.ToCieLuv(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/CieLuvAndHsvConversionTests.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="CieLuv"/>-<see cref="Hsv"/> conversions.
+    /// </summary>
+    public class CieLuvAndHsvConversionTests
+    {
+        private static readonly ApproximateColorSpaceComparer ColorSpaceComparer = new ApproximateColorSpaceComparer(.0002F);
+        private static readonly ColorSpaceConverter Converter = new ColorSpaceConverter();
+
+        /// <summary>
+        /// Tests conversion from <see cref="CieLuv"/> to <see cref="Hsv"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0)]
+        [InlineData(36.0555, 93.6901, 10.01514, 347.3767, 0.8314762, 0.6444615)]
+        public void Convert_CieLuv_to_Hsv(float l, float u, float v, float h, float s, float v2)
+        {
+            // Arrange
+            var input = new CieLuv(l, u, v);
+            var expected = new Hsv(h, s, v2);
+
+            Span<CieLuv> inputSpan = new CieLuv[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="CieLuv"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0)]
+        [InlineData(347.3767, 0.8314762, 0.6444615, 36.0555, 93.69012, 10.01514)]
+        public void Convert_Hsv_to_CieLuv(float h, float s, float v2, float l, float u, float v)
+        {
+            // Arrange
+            var input = new Hsv(h, s, v2);
+            var expected = new CieLuv(l, u, v);
+
+            Span<Hsv> inputSpan = new Hsv[5];
+            inputSpan.Fill(input);
+
+            Span<CieLuv> actualSpan = new CieLuv[5];
+
+            // Act
+            var actual = Converter.ToCieLuv(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/CieLuvAndHunterLabConversionTests.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="CieLuv"/>-<see cref="HunterLab"/> conversions.
+    /// </summary>
+    public class CieLuvAndHunterLabConversionTests
+    {
+        private static readonly ApproximateColorSpaceComparer ColorSpaceComparer = new ApproximateColorSpaceComparer(.0002F);
+        private static readonly ColorSpaceConverter Converter = new ColorSpaceConverter();
+
+        /// <summary>
+        /// Tests conversion from <see cref="CieLuv"/> to <see cref="HunterLab"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0)]
+        [InlineData(36.0555, 93.6901, 10.01514, 30.19531, 46.4312, 11.16259)]
+        public void Convert_CieLuv_to_HunterLab(float l, float u, float v, float l2, float a, float b)
+        {
+            // Arrange
+            var input = new CieLuv(l, u, v);
+            var expected = new HunterLab(l2, a, b);
+
+            Span<CieLuv> inputSpan = new CieLuv[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="CieLuv"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0)]
+        [InlineData(30.19531, 46.4312, 11.16259, 36.0555, 93.6901, 10.01514)]
+        public void Convert_HunterLab_to_CieLuv(float l2, float a, float b, float l, float u, float v)
+        {
+            // Arrange
+            var input = new HunterLab(l2, a, b);
+            var expected = new CieLuv(l, u, v);
+
+            Span<HunterLab> inputSpan = new HunterLab[5];
+            inputSpan.Fill(input);
+
+            Span<CieLuv> actualSpan = new CieLuv[5];
+
+            // Act
+            var actual = Converter.ToCieLuv(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/CieLuvAndLinearRgbConversionTests.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="CieLuv"/>-<see cref="LinearRgb"/> conversions.
+    /// </summary>
+    public class CieLuvAndLinearRgbConversionTests
+    {
+        private static readonly ApproximateColorSpaceComparer ColorSpaceComparer = new ApproximateColorSpaceComparer(.0002F);
+        private static readonly ColorSpaceConverter Converter = new ColorSpaceConverter();
+
+        /// <summary>
+        /// Tests conversion from <see cref="CieLuv"/> to <see cref="LinearRgb"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0)]
+        [InlineData(36.0555, 93.6901, 10.01514, 0.3729299, 0.01141088, 0.04014909)]
+        public void Convert_CieLuv_to_LinearRgb(float l, float u, float v, float r, float g, float b)
+        {
+            // Arrange
+            var input = new CieLuv(l, u, v);
+            var expected = new LinearRgb(r, g, b);
+
+            Span<CieLuv> inputSpan = new CieLuv[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="CieLuv"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0)]
+        [InlineData(0.3729299, 0.01141088, 0.04014909, 36.0555, 93.6901, 10.01511)]
+        public void Convert_LinearRgb_to_CieLuv(float r, float g, float b, float l, float u, float v)
+        {
+            // Arrange
+            var input = new LinearRgb(r, g, b);
+            var expected = new CieLuv(l, u, v);
+
+            Span<LinearRgb> inputSpan = new LinearRgb[5];
+            inputSpan.Fill(input);
+
+            Span<CieLuv> actualSpan = new CieLuv[5];
+
+            // Act
+            var actual = Converter.ToCieLuv(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/CieLuvAndLmsConversionTests.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="CieLuv"/>-<see cref="Lms"/> conversions.
+    /// </summary>
+    public class CieLuvAndLmsConversionTests
+    {
+        private static readonly ApproximateColorSpaceComparer ColorSpaceComparer = new ApproximateColorSpaceComparer(.0002F);
+        private static readonly ColorSpaceConverter Converter = new ColorSpaceConverter();
+
+        /// <summary>
+        /// Tests conversion from <see cref="CieLuv"/> to <see cref="Lms"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0)]
+        [InlineData(36.0555, 93.6901, 10.01514, 0.164352, 0.03267485, 0.0483408)]
+        public void Convert_CieLuv_to_Lms(float l, float u, float v, float l2, float m, float s)
+        {
+            // Arrange
+            var input = new CieLuv(l, u, v);
+            var expected = new Lms(l2, m, s);
+
+            Span<CieLuv> inputSpan = new CieLuv[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="CieLuv"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0)]
+        [InlineData(0.164352, 0.03267485, 0.0483408, 36.0555, 93.69009, 10.01514)]
+        public void Convert_Lms_to_CieLuv(float l2, float m, float s, float l, float u, float v)
+        {
+            // Arrange
+            var input = new Lms(l2, m, s);
+            var expected = new CieLuv(l, u, v);
+
+            Span<Lms> inputSpan = new Lms[5];
+            inputSpan.Fill(input);
+
+            Span<CieLuv> actualSpan = new CieLuv[5];
+
+            // Act
+            var actual = Converter.ToCieLuv(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/CieLuvAndRgbConversionTests.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="CieLuv"/>-<see cref="Rgb"/> conversions.
+    /// </summary>
+    public class CieLuvAndRgbConversionTests
+    {
+        private static readonly ApproximateColorSpaceComparer ColorSpaceComparer = new ApproximateColorSpaceComparer(.0002F);
+        private static readonly ColorSpaceConverter Converter = new ColorSpaceConverter();
+
+        /// <summary>
+        /// Tests conversion from <see cref="CieLuv"/> to <see cref="Rgb"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0)]
+        [InlineData(36.0555, 93.6901, 10.01514, 0.6444615, 0.1086071, 0.2213444)]
+        public void Convert_CieLuv_to_Rgb(float l, float u, float v, float r, float g, float b)
+        {
+            // Arrange
+            var input = new CieLuv(l, u, v);
+            var expected = new Rgb(r, g, b);
+
+            Span<CieLuv> inputSpan = new CieLuv[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="CieLuv"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0)]
+        [InlineData(0.6444615, 0.1086071, 0.2213444, 36.0555, 93.69012, 10.01514)]
+        public void Convert_Rgb_to_CieLuv(float r, float g, float b, float l, float u, float v)
+        {
+            // Arrange
+            var input = new Rgb(r, g, b);
+            var expected = new CieLuv(l, u, v);
+
+            Span<Rgb> inputSpan = new Rgb[5];
+            inputSpan.Fill(input);
+
+            Span<CieLuv> actualSpan = new CieLuv[5];
+
+            // Act
+            var actual = Converter.ToCieLuv(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/CieLuvAndYCbCrConversionTests.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="CieLuv"/>-<see cref="YCbCr"/> conversions.
+    /// </summary>
+    public class CieLuvAndYCbCrConversionTests
+    {
+        private static readonly ApproximateColorSpaceComparer ColorSpaceComparer = new ApproximateColorSpaceComparer(.0002F);
+        private static readonly ColorSpaceConverter Converter = new ColorSpaceConverter();
+
+        /// <summary>
+        /// Tests conversion from <see cref="CieLuv"/> to <see cref="YCbCr"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 128, 128)]
+        [InlineData(36.0555, 93.6901, 10.01514, 71.8283, 119.3174, 193.9839)]
+        public void Convert_CieLuv_to_YCbCr(float l, float u, float v, float y, float cb, float cr)
+        {
+            // Arrange
+            var input = new CieLuv(l, u, v);
+            var expected = new YCbCr(y, cb, cr);
+
+            Span<CieLuv> inputSpan = new CieLuv[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="CieLuv"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 128, 128, 0, 0, 0)]
+        [InlineData(71.8283, 119.3174, 193.9839, 36.00565, 93.44593, 10.2234)]
+        public void Convert_YCbCr_to_CieLuv(float y, float cb, float cr, float l, float u, float v)
+        {
+            // Arrange
+            var input = new YCbCr(y, cb, cr);
+            var expected = new CieLuv(l, u, v);
+
+            Span<YCbCr> inputSpan = new YCbCr[5];
+            inputSpan.Fill(input);
+
+            Span<CieLuv> actualSpan = new CieLuv[5];
+
+            // Act
+            var actual = Converter.ToCieLuv(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);
+            }
+        }
+    }
+}