Add CieLchuv

src/ImageSharp/ColorSpaces/CieLchuv.cs

@@ -0,0 +1,247 @@
+// <copyright file="CieLchuv.cs" company="James Jackson-South">
+// Copyright (c) James Jackson-South and contributors.
+// Licensed under the Apache License, Version 2.0.
+// </copyright>
+
+namespace ImageSharp.ColorSpaces
+{
+    using System;
+    using System.ComponentModel;
+    using System.Numerics;
+    using System.Runtime.CompilerServices;
+
+    /// <summary>
+    /// Represents the CIE L*C*h°, cylindrical form of the CIE L*u*v* 1976 color.
+    /// <see href="https://en.wikipedia.org/wiki/Lab_color_space#Cylindrical_representation:_CieLchuv_or_CIEHLC"/>
+    /// </summary>
+    public struct CieLchuv : IColorVector, IEquatable<CieLchuv>, IAlmostEquatable<CieLchuv, float>
+    {
+        /// <summary>
+        /// D50 standard illuminant.
+        /// Used when reference white is not specified explicitly.
+        /// </summary>
+        public static readonly CieXyz DefaultWhitePoint = Illuminants.D65;
+
+        /// <summary>
+        /// Represents a <see cref="CieLchuv"/> that has L, C, H values set to zero.
+        /// </summary>
+        public static readonly CieLchuv Empty = default(CieLchuv);
+
+        /// <summary>
+        /// The backing vector for SIMD support.
+        /// </summary>
+        private readonly Vector3 backingVector;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CieLchuv"/> struct.
+        /// </summary>
+        /// <param name="l">The lightness dimension.</param>
+        /// <param name="c">The chroma, relative saturation.</param>
+        /// <param name="h">The hue in degrees.</param>
+        /// <remarks>Uses <see cref="DefaultWhitePoint"/> as white point.</remarks>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public CieLchuv(float l, float c, float h)
+            : this(new Vector3(l, c, h), DefaultWhitePoint)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CieLchuv"/> struct.
+        /// </summary>
+        /// <param name="l">The lightness dimension.</param>
+        /// <param name="c">The chroma, relative saturation.</param>
+        /// <param name="h">The hue in degrees.</param>
+        /// <param name="whitePoint">The reference white point. <see cref="Illuminants"/></param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public CieLchuv(float l, float c, float h, CieXyz whitePoint)
+            : this(new Vector3(l, c, h), whitePoint)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CieLchuv"/> struct.
+        /// </summary>
+        /// <param name="vector">The vector representing the l, c, h components.</param>
+        /// <remarks>Uses <see cref="DefaultWhitePoint"/> as white point.</remarks>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public CieLchuv(Vector3 vector)
+            : this(vector, DefaultWhitePoint)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CieLchuv"/> struct.
+        /// </summary>
+        /// <param name="vector">The vector representing the l, c, h components.</param>
+        /// <param name="whitePoint">The reference white point. <see cref="Illuminants"/></param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public CieLchuv(Vector3 vector, CieXyz whitePoint)
+            : this()
+        {
+            this.backingVector = vector;
+            this.WhitePoint = whitePoint;
+        }
+
+        /// <summary>
+        /// Gets the reference white point of this color
+        /// </summary>
+        public CieXyz WhitePoint
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get;
+        }
+
+        /// <summary>
+        /// Gets the lightness dimension.
+        /// <remarks>A value ranging between 0 (black), 100 (diffuse white) or higher (specular white).</remarks>
+        /// </summary>
+        public float L
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => this.backingVector.X;
+        }
+
+        /// <summary>
+        /// Gets the a chroma component.
+        /// <remarks>A value ranging from 0 to 100.</remarks>
+        /// </summary>
+        public float C
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => this.backingVector.Y;
+        }
+
+        /// <summary>
+        /// Gets the h° hue component in degrees.
+        /// <remarks>A value ranging from 0 to 360.</remarks>
+        /// </summary>
+        public float H
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => this.backingVector.Z;
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether this <see cref="CieLchuv"/> is empty.
+        /// </summary>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public bool IsEmpty => this.Equals(Empty);
+
+        /// <inheritdoc />
+        public Vector3 Vector
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => this.backingVector;
+        }
+
+        /// <summary>
+        /// Compares two <see cref="CieLchuv"/> objects for equality.
+        /// </summary>
+        /// <param name="left">
+        /// The <see cref="CieLchuv"/> on the left side of the operand.
+        /// </param>
+        /// <param name="right">
+        /// The <see cref="CieLchuv"/> on the right side of the operand.
+        /// </param>
+        /// <returns>
+        /// True if the current left is equal to the <paramref name="right"/> parameter; otherwise, false.
+        /// </returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool operator ==(CieLchuv left, CieLchuv right)
+        {
+            return left.Equals(right);
+        }
+
+        /// <summary>
+        /// Compares two <see cref="CieLchuv"/> objects for inequality
+        /// </summary>
+        /// <param name="left">
+        /// The <see cref="CieLchuv"/> on the left side of the operand.
+        /// </param>
+        /// <param name="right">
+        /// The <see cref="CieLchuv"/> on the right side of the operand.
+        /// </param>
+        /// <returns>
+        /// True if the current left is unequal to the <paramref name="right"/> parameter; otherwise, false.
+        /// </returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool operator !=(CieLchuv left, CieLchuv right)
+        {
+            return !left.Equals(right);
+        }
+
+        /// <inheritdoc/>
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                int hashCode = this.WhitePoint.GetHashCode();
+                hashCode = (hashCode * 397) ^ this.backingVector.GetHashCode();
+                return hashCode;
+            }
+        }
+
+        /// <inheritdoc/>
+        public override string ToString()
+        {
+            if (this.IsEmpty)
+            {
+                return "CieLchuv [Empty]";
+            }
+
+            return $"CieLchuv [ L={this.L:#0.##}, C={this.C:#0.##}, H={this.H:#0.##}]";
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override bool Equals(object obj)
+        {
+            if (obj is CieLchuv)
+            {
+                return this.Equals((CieLchuv)obj);
+            }
+
+            return false;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(CieLchuv other)
+        {
+            return this.backingVector.Equals(other.backingVector)
+                && this.WhitePoint.Equals(other.WhitePoint);
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool AlmostEquals(CieLchuv other, float precision)
+        {
+            Vector3 result = Vector3.Abs(this.backingVector - other.backingVector);
+
+            return this.WhitePoint.Equals(other.WhitePoint)
+                   && result.X <= precision
+                   && result.Y <= precision
+                   && result.Z <= precision;
+        }
+
+        /// <summary>
+        /// Computes the saturation of the color (chroma normalized by lightness)
+        /// </summary>
+        /// <remarks>
+        /// A value ranging from 0 to 100.
+        /// </remarks>
+        /// <returns>The <see cref="float"/></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float Saturation()
+        {
+            float result = 100 * (this.C / this.L);
+
+            if (float.IsNaN(result))
+            {
+                return 0;
+            }
+
+            return result;
+        }
+    }
+}

src/ImageSharp/ColorSpaces/Conversion/ColorSpaceConverter.Adapt.cs

@@ -10,9 +10,9 @@ namespace ImageSharp.ColorSpaces.Conversion
     using ImageSharp.ColorSpaces;
     using ImageSharp.ColorSpaces.Conversion.Implementation.Rgb;
 
-    /// <summary>
-    /// Converts between color spaces ensuring that the color is adapted using chromatic adaptation.
-    /// </summary>
+    /// <content>
+    /// Performs chromatic adaptation on the various color spaces.
+    /// </content>
     public partial class ColorSpaceConverter
     {
         /// <summary>
@@ -81,6 +81,29 @@ namespace ImageSharp.ColorSpaces.Conversion
             return this.ToCieLch(labColor);
         }
 
+        /// <summary>
+        /// Adapts <see cref="CieLchuv"/> color from the source white point to white point set in <see cref="TargetLabWhitePoint"/>.
+        /// </summary>
+        /// <param name="color">The color to adapt</param>
+        /// <returns>The adapted color</returns>
+        public CieLchuv Adapt(CieLchuv color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            if (!this.IsChromaticAdaptationPerformed)
+            {
+                throw new InvalidOperationException("Cannot perform chromatic adaptation, provide a chromatic adaptation method and white point.");
+            }
+
+            if (color.WhitePoint.Equals(this.TargetLabWhitePoint))
+            {
+                return color;
+            }
+
+            CieLuv luvColor = this.ToCieLuv(color);
+            return this.ToCieLchuv(luvColor);
+        }
+
         /// <summary>
         /// Adapts <see cref="CieLuv"/> color from the source white point to white point set in <see cref="TargetLuvWhitePoint"/>.
         /// </summary>

src/ImageSharp/ColorSpaces/Conversion/ColorSpaceConverter.CieLab.cs

@@ -9,9 +9,9 @@ namespace ImageSharp.ColorSpaces.Conversion
     using ImageSharp.ColorSpaces.Conversion.Implementation.CieLab;
     using ImageSharp.ColorSpaces.Conversion.Implementation.CieLch;
 
-    /// <summary>
-    /// Converts between color spaces ensuring that the color is adapted using chromatic adaptation.
-    /// </summary>
+    /// <content>
+    /// Allows conversion to <see cref="CieLab"/>.
+    /// </content>
     public partial class ColorSpaceConverter
     {
         /// <summary>
@@ -40,6 +40,19 @@ namespace ImageSharp.ColorSpaces.Conversion
             return this.Adapt(unadapted);
         }
 
+        /// <summary>
+        /// Converts a <see cref="CieLchuv"/> into a <see cref="CieLab"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="CieLab"/></returns>
+        public CieLab ToCieLab(CieLchuv color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+            return this.ToCieLab(xyzColor);
+        }
+
         /// <summary>
         /// Converts a <see cref="CieLuv"/> into a <see cref="CieLab"/>
         /// </summary>

src/ImageSharp/ColorSpaces/Conversion/ColorSpaceConverter.CieLch.cs

@@ -7,9 +7,9 @@ namespace ImageSharp.ColorSpaces.Conversion
 {
     using ImageSharp.ColorSpaces.Conversion.Implementation.CieLch;
 
-    /// <summary>
-    /// Converts between color spaces ensuring that the color is adapted using chromatic adaptation.
-    /// </summary>
+    /// <content>
+    /// Allows conversion to <see cref="CieLch"/>.
+    /// </content>
     public partial class ColorSpaceConverter
     {
         /// <summary>
@@ -33,6 +33,19 @@ namespace ImageSharp.ColorSpaces.Conversion
             return CieLabToCieLchConverter.Convert(adapted);
         }
 
+        /// <summary>
+        /// Converts a <see cref="CieLchuv"/> into a <see cref="CieLch"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="CieLch"/></returns>
+        public CieLch ToCieLch(CieLchuv color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+            return this.ToCieLch(xyzColor);
+        }
+
         /// <summary>
         /// Converts a <see cref="CieLuv"/> into a <see cref="CieLch"/>
         /// </summary>

src/ImageSharp/ColorSpaces/Conversion/ColorSpaceConverter.CieLchuv.cs

@@ -0,0 +1,192 @@
+// <copyright file="ColorSpaceConverter.cs" company="James Jackson-South">
+// Copyright (c) James Jackson-South and contributors.
+// Licensed under the Apache License, Version 2.0.
+// </copyright>
+
+namespace ImageSharp.ColorSpaces.Conversion
+{
+    using ImageSharp.ColorSpaces.Conversion.Implementation.CieLchuv;
+
+    /// <content>
+    /// Allows conversion to <see cref="CieLchuv"/>.
+    /// </content>
+    public partial class ColorSpaceConverter
+    {
+        /// <summary>
+        /// The converter for converting between CieLab to CieLchuv.
+        /// </summary>
+        private static readonly CieLuvToCieLchuvConverter CieLuvToCieLchuvConverter = new CieLuvToCieLchuvConverter();
+
+        /// <summary>
+        /// Converts a <see cref="CieLab"/> into a <see cref="CieLchuv"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="CieLchuv"/></returns>
+        public CieLchuv ToCieLchuv(CieLab color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+            return this.ToCieLchuv(xyzColor);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="CieLch"/> into a <see cref="CieLchuv"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="CieLchuv"/></returns>
+        public CieLchuv ToCieLchuv(CieLch color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+            return this.ToCieLchuv(xyzColor);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="CieLuv"/> into a <see cref="CieLchuv"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="CieLchuv"/></returns>
+        public CieLchuv ToCieLchuv(CieLuv color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            // Adaptation
+            CieLuv adapted = this.IsChromaticAdaptationPerformed ? this.Adapt(color) : color;
+
+            // Conversion
+            return CieLuvToCieLchuvConverter.Convert(adapted);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="CieXyy"/> into a <see cref="CieLchuv"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="CieLchuv"/></returns>
+        public CieLchuv ToCieLchuv(CieXyy color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+            return this.ToCieLchuv(xyzColor);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="CieXyz"/> into a <see cref="CieLchuv"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="CieLchuv"/></returns>
+        public CieLchuv ToCieLchuv(CieXyz color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieLab labColor = this.ToCieLab(color);
+            return this.ToCieLchuv(labColor);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="Cmyk"/> into a <see cref="CieLchuv"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="CieLchuv"/></returns>
+        public CieLchuv ToCieLchuv(Cmyk color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+            return this.ToCieLchuv(xyzColor);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="Hsl"/> into a <see cref="CieLchuv"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="CieLchuv"/></returns>
+        public CieLchuv ToCieLchuv(Hsl color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+            return this.ToCieLchuv(xyzColor);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="Hsv"/> into a <see cref="CieLchuv"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="CieLchuv"/></returns>
+        public CieLchuv ToCieLchuv(Hsv color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+            return this.ToCieLchuv(xyzColor);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="HunterLab"/> into a <see cref="CieLchuv"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="CieLchuv"/></returns>
+        public CieLchuv ToCieLchuv(HunterLab color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+            return this.ToCieLchuv(xyzColor);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="LinearRgb"/> into a <see cref="CieLchuv"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="CieLchuv"/></returns>
+        public CieLchuv ToCieLchuv(LinearRgb color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+            return this.ToCieLchuv(xyzColor);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="Lms"/> into a <see cref="CieLchuv"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="CieLchuv"/></returns>
+        public CieLchuv ToCieLchuv(Lms color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+            return this.ToCieLchuv(xyzColor);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="Rgb"/> into a <see cref="CieLchuv"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="CieLchuv"/></returns>
+        public CieLchuv ToCieLchuv(Rgb color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+            return this.ToCieLchuv(xyzColor);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="YCbCr"/> into a <see cref="CieLchuv"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="CieLchuv"/></returns>
+        public CieLchuv ToCieLchuv(YCbCr color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+            return this.ToCieLchuv(xyzColor);
+        }
+    }
+}

src/ImageSharp/ColorSpaces/Conversion/ColorSpaceConverter.CieLuv.cs

@@ -6,13 +6,16 @@
 namespace ImageSharp.ColorSpaces.Conversion
 {
     using ImageSharp.ColorSpaces;
+    using ImageSharp.ColorSpaces.Conversion.Implementation.CieLchuv;
     using ImageSharp.ColorSpaces.Conversion.Implementation.CieLuv;
 
-    /// <summary>
-    /// Converts between color spaces ensuring that the color is adapted using chromatic adaptation.
-    /// </summary>
+    /// <content>
+    /// Allows conversion to <see cref="CieLuv"/>.
+    /// </content>
     public partial class ColorSpaceConverter
     {
+        private static readonly CieLchuvToCieLuvConverter CieLchuvToCieLuvConverter = new CieLchuvToCieLuvConverter();
+
         /// <summary>
         /// Converts a <see cref="CieLab"/> into a <see cref="CieLuv"/>
         /// </summary>
@@ -39,6 +42,27 @@ namespace ImageSharp.ColorSpaces.Conversion
             return this.ToCieLuv(xyzColor);
         }
 
+        /// <summary>
+        /// Converts a <see cref="CieLchuv"/> into a <see cref="CieLuv"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="CieLab"/></returns>
+        public CieLuv ToCieLuv(CieLchuv color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            // Conversion (perserving white point)
+            CieLuv unadapted = CieLchuvToCieLuvConverter.Convert(color);
+
+            if (!this.IsChromaticAdaptationPerformed)
+            {
+                return unadapted;
+            }
+
+            // Adaptation
+            return this.Adapt(unadapted);
+        }
+
         /// <summary>
         /// Converts a <see cref="CieXyy"/> into a <see cref="CieLuv"/>
         /// </summary>

src/ImageSharp/ColorSpaces/Conversion/ColorSpaceConverter.CieXyy.cs

@@ -7,9 +7,9 @@ namespace ImageSharp.ColorSpaces.Conversion
 {
     using ImageSharp.ColorSpaces.Conversion.Implementation.CieXyy;
 
-    /// <summary>
-    /// Converts between color spaces ensuring that the color is adapted using chromatic adaptation.
-    /// </summary>
+    /// <content>
+    /// Allows conversion to <see cref="CieXyy"/>.
+    /// </content>
     public partial class ColorSpaceConverter
     {
         private static readonly CieXyzAndCieXyyConverter CieXyzAndCieXyyConverter = new CieXyzAndCieXyyConverter();
@@ -42,6 +42,20 @@ namespace ImageSharp.ColorSpaces.Conversion
             return this.ToCieXyy(xyzColor);
         }
 
+        /// <summary>
+        /// Converts a <see cref="CieLchuv"/> into a <see cref="CieXyy"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="CieXyy"/></returns>
+        public CieXyy ToCieXyy(CieLchuv color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+
+            return this.ToCieXyy(xyzColor);
+        }
+
         /// <summary>
         /// Converts a <see cref="CieLuv"/> into a <see cref="CieXyy"/>
         /// </summary>

src/ImageSharp/ColorSpaces/Conversion/ColorSpaceConverter.CieXyz.cs

@@ -11,9 +11,9 @@ namespace ImageSharp.ColorSpaces.Conversion
     using ImageSharp.ColorSpaces.Conversion.Implementation.HunterLab;
     using ImageSharp.ColorSpaces.Conversion.Implementation.Rgb;
 
-    /// <summary>
-    /// Converts between color spaces ensuring that the color is adapted using chromatic adaptation.
-    /// </summary>
+    /// <content>
+    /// Allows conversion to <see cref="CieXyz"/>.
+    /// </content>
     public partial class ColorSpaceConverter
     {
         private static readonly CieLabToCieXyzConverter CieLabToCieXyzConverter = new CieLabToCieXyzConverter();
@@ -60,6 +60,23 @@ namespace ImageSharp.ColorSpaces.Conversion
             return this.ToCieXyz(labColor);
         }
 
+        /// <summary>
+        /// Converts a <see cref="CieLuv"/> into a <see cref="CieXyz"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="CieXyz"/></returns>
+        public CieXyz ToCieXyz(CieLchuv color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            // Conversion to Luv
+            CieLuv luvColor = CieLchuvToCieLuvConverter.Convert(color);
+
+            // Conversion to XYZ (incl. adaptation)
+            CieXyz result = this.ToCieXyz(luvColor);
+            return result;
+        }
+
         /// <summary>
         /// Converts a <see cref="CieLuv"/> into a <see cref="CieXyz"/>
         /// </summary>

src/ImageSharp/ColorSpaces/Conversion/ColorSpaceConverter.Cmyk.cs

@@ -8,9 +8,9 @@ namespace ImageSharp.ColorSpaces.Conversion
     using ImageSharp.ColorSpaces;
     using ImageSharp.ColorSpaces.Conversion.Implementation.Cmyk;
 
-    /// <summary>
-    /// Converts between color spaces ensuring that the color is adapted using chromatic adaptation.
-    /// </summary>
+    /// <content>
+    /// Allows conversion to <see cref="Cmyk"/>.
+    /// </content>
     public partial class ColorSpaceConverter
     {
         private static readonly CmykAndRgbConverter CmykAndRgbConverter = new CmykAndRgbConverter();
@@ -43,6 +43,20 @@ namespace ImageSharp.ColorSpaces.Conversion
             return this.ToCmyk(xyzColor);
         }
 
+        /// <summary>
+        /// Converts a <see cref="CieLchuv"/> into a <see cref="Cmyk"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="Cmyk"/></returns>
+        public Cmyk ToCmyk(CieLchuv color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+
+            return this.ToCmyk(xyzColor);
+        }
+
         /// <summary>
         /// Converts a <see cref="CieLuv"/> into a <see cref="Cmyk"/>
         /// </summary>

src/ImageSharp/ColorSpaces/Conversion/ColorSpaceConverter.Hsl.cs

@@ -8,9 +8,9 @@ namespace ImageSharp.ColorSpaces.Conversion
     using ImageSharp.ColorSpaces;
     using ImageSharp.ColorSpaces.Conversion.Implementation.Hsl;
 
-    /// <summary>
-    /// Converts between color spaces ensuring that the color is adapted using chromatic adaptation.
-    /// </summary>
+    /// <content>
+    /// Allows conversion to <see cref="Hsl"/>.
+    /// </content>
     public partial class ColorSpaceConverter
     {
         private static readonly HslAndRgbConverter HslAndRgbConverter = new HslAndRgbConverter();
@@ -43,6 +43,20 @@ namespace ImageSharp.ColorSpaces.Conversion
             return this.ToHsl(xyzColor);
         }
 
+        /// <summary>
+        /// Converts a <see cref="CieLchuv"/> into a <see cref="Hsl"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="Hsl"/></returns>
+        public Hsl ToHsl(CieLchuv color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+
+            return this.ToHsl(xyzColor);
+        }
+
         /// <summary>
         /// Converts a <see cref="CieLuv"/> into a <see cref="Hsl"/>
         /// </summary>

src/ImageSharp/ColorSpaces/Conversion/ColorSpaceConverter.Hsv.cs

@@ -8,9 +8,9 @@ namespace ImageSharp.ColorSpaces.Conversion
     using ImageSharp.ColorSpaces;
     using ImageSharp.ColorSpaces.Conversion.Implementation.Hsv;
 
-    /// <summary>
-    /// Converts between color spaces ensuring that the color is adapted using chromatic adaptation.
-    /// </summary>
+    /// <content>
+    /// Allows conversion to <see cref="Hsv"/>.
+    /// </content>
     public partial class ColorSpaceConverter
     {
         private static readonly HsvAndRgbConverter HsvAndRgbConverter = new HsvAndRgbConverter();
@@ -43,6 +43,20 @@ namespace ImageSharp.ColorSpaces.Conversion
             return this.ToHsv(xyzColor);
         }
 
+        /// <summary>
+        /// Converts a <see cref="CieLchuv"/> into a <see cref="Hsv"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="Hsv"/></returns>
+        public Hsv ToHsv(CieLchuv color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+
+            return this.ToHsv(xyzColor);
+        }
+
         /// <summary>
         /// Converts a <see cref="CieLuv"/> into a <see cref="Hsv"/>
         /// </summary>

src/ImageSharp/ColorSpaces/Conversion/ColorSpaceConverter.HunterLab.cs

@@ -7,9 +7,9 @@ namespace ImageSharp.ColorSpaces.Conversion
 {
     using ImageSharp.ColorSpaces.Conversion.Implementation.HunterLab;
 
-    /// <summary>
-    /// Converts between color spaces ensuring that the color is adapted using chromatic adaptation.
-    /// </summary>
+    /// <content>
+    /// Allows conversion to <see cref="HunterLab"/>.
+    /// </content>
     public partial class ColorSpaceConverter
     {
         /// <summary>
@@ -38,6 +38,19 @@ namespace ImageSharp.ColorSpaces.Conversion
             return this.ToHunterLab(xyzColor);
         }
 
+        /// <summary>
+        /// Converts a <see cref="CieLchuv"/> into a <see cref="HunterLab"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="HunterLab"/></returns>
+        public HunterLab ToHunterLab(CieLchuv color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+            return this.ToHunterLab(xyzColor);
+        }
+
         /// <summary>
         /// Converts a <see cref="CieLuv"/> into a <see cref="HunterLab"/>
         /// </summary>

src/ImageSharp/ColorSpaces/Conversion/ColorSpaceConverter.LinearRgb.cs

@@ -7,9 +7,9 @@ namespace ImageSharp.ColorSpaces.Conversion
 {
     using ImageSharp.ColorSpaces.Conversion.Implementation.Rgb;
 
-    /// <summary>
-    /// Converts between color spaces ensuring that the color is adapted using chromatic adaptation.
-    /// </summary>
+    /// <content>
+    /// Allows conversion to <see cref="LinearRgb"/>.
+    /// </content>
     public partial class ColorSpaceConverter
     {
         private static readonly RgbToLinearRgbConverter RgbToLinearRgbConverter = new RgbToLinearRgbConverter();
@@ -42,6 +42,19 @@ namespace ImageSharp.ColorSpaces.Conversion
             return this.ToLinearRgb(xyzColor);
         }
 
+        /// <summary>
+        /// Converts a <see cref="CieLchuv"/> into a <see cref="LinearRgb"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="LinearRgb"/></returns>
+        public LinearRgb ToLinearRgb(CieLchuv color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+            return this.ToLinearRgb(xyzColor);
+        }
+
         /// <summary>
         /// Converts a <see cref="CieLuv"/> into a <see cref="LinearRgb"/>
         /// </summary>

src/ImageSharp/ColorSpaces/Conversion/ColorSpaceConverter.Lms.cs

@@ -7,9 +7,9 @@ namespace ImageSharp.ColorSpaces.Conversion
 {
     using ImageSharp.ColorSpaces;
 
-    /// <summary>
-    /// Converts between color spaces ensuring that the color is adapted using chromatic adaptation.
-    /// </summary>
+    /// <content>
+    /// Allows conversion to <see cref="Lms"/>.
+    /// </content>
     public partial class ColorSpaceConverter
     {
         /// <summary>
@@ -38,6 +38,19 @@ namespace ImageSharp.ColorSpaces.Conversion
             return this.ToLms(xyzColor);
         }
 
+        /// <summary>
+        /// Converts a <see cref="CieLchuv"/> into a <see cref="Lms"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="Lms"/></returns>
+        public Lms ToLms(CieLchuv color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+            return this.ToLms(xyzColor);
+        }
+
         /// <summary>
         /// Converts a <see cref="CieLuv"/> into a <see cref="Lms"/>
         /// </summary>

src/ImageSharp/ColorSpaces/Conversion/ColorSpaceConverter.Rgb.cs

@@ -7,9 +7,9 @@ namespace ImageSharp.ColorSpaces.Conversion
 {
     using ImageSharp.ColorSpaces.Conversion.Implementation.Rgb;
 
-    /// <summary>
-    /// Converts between color spaces ensuring that the color is adapted using chromatic adaptation.
-    /// </summary>
+    /// <content>
+    /// Allows conversion to <see cref="Rgb"/>.
+    /// </content>
     public partial class ColorSpaceConverter
     {
         private static readonly LinearRgbToRgbConverter LinearRgbToRgbConverter = new LinearRgbToRgbConverter();
@@ -40,6 +40,19 @@ namespace ImageSharp.ColorSpaces.Conversion
             return this.ToRgb(xyzColor);
         }
 
+        /// <summary>
+        /// Converts a <see cref="CieLchuv"/> into a <see cref="Rgb"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="Rgb"/></returns>
+        public Rgb ToRgb(CieLchuv color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+            return this.ToRgb(xyzColor);
+        }
+
         /// <summary>
         /// Converts a <see cref="CieLuv"/> into a <see cref="Rgb"/>
         /// </summary>

src/ImageSharp/ColorSpaces/Conversion/ColorSpaceConverter.YCbCr.cs

@@ -8,9 +8,9 @@ namespace ImageSharp.ColorSpaces.Conversion
     using ImageSharp.ColorSpaces;
     using ImageSharp.ColorSpaces.Conversion.Implementation.YCbCr;
 
-    /// <summary>
-    /// Converts between color spaces ensuring that the color is adapted using chromatic adaptation.
-    /// </summary>
+    /// <content>
+    /// Allows conversion to <see cref="YCbCr"/>.
+    /// </content>
     public partial class ColorSpaceConverter
     {
         private static readonly YCbCrAndRgbConverter YCbCrAndRgbConverter = new YCbCrAndRgbConverter();
@@ -43,6 +43,20 @@ namespace ImageSharp.ColorSpaces.Conversion
             return this.ToYCbCr(xyzColor);
         }
 
+        /// <summary>
+        /// Converts a <see cref="CieLchuv"/> into a <see cref="YCbCr"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="YCbCr"/></returns>
+        public YCbCr ToYCbCr(CieLchuv color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+
+            return this.ToYCbCr(xyzColor);
+        }
+
         /// <summary>
         /// Converts a <see cref="CieLuv"/> into a <see cref="YCbCr"/>
         /// </summary>

src/ImageSharp/ColorSpaces/Conversion/ColorSpaceConverter.cs

@@ -80,10 +80,7 @@ namespace ImageSharp.ColorSpaces.Conversion
         /// </summary>
         public Matrix4x4 LmsAdaptationMatrix
         {
-            get
-            {
-                return this.transformationMatrix;
-            }
+            get => this.transformationMatrix;
 
             set
             {

src/ImageSharp/ColorSpaces/Conversion/Implementation/CieLch/CIeLchToCieLabConverter.cs

@@ -12,7 +12,7 @@ namespace ImageSharp.ColorSpaces.Conversion.Implementation.CieLch
     /// <summary>
     /// Converts from <see cref="CieLch"/> to <see cref="CieLab"/>.
     /// </summary>
-    public class CieLchToCieLabConverter : IColorConversion<CieLch, CieLab>
+    internal class CieLchToCieLabConverter : IColorConversion<CieLch, CieLab>
     {
         /// <inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -20,7 +20,8 @@ namespace ImageSharp.ColorSpaces.Conversion.Implementation.CieLch
         {
             DebugGuard.NotNull(input, nameof(input));
 
-            // Conversion algorithm described here: https://en.wikipedia.org/wiki/Lab_color_space#Cylindrical_representation:_CIELCh_or_CIEHLC
+            // Conversion algorithm described here:
+            // https://en.wikipedia.org/wiki/Lab_color_space#Cylindrical_representation:_CIELCh_or_CIEHLC
             float l = input.L, c = input.C, hDegrees = input.H;
             float hRadians = MathF.DegreeToRadian(hDegrees);
 

src/ImageSharp/ColorSpaces/Conversion/Implementation/CieLch/CieLabToCieLchConverter.cs

@@ -20,7 +20,8 @@ namespace ImageSharp.ColorSpaces.Conversion.Implementation.CieLch
         {
             DebugGuard.NotNull(input, nameof(input));
 
-            // Conversion algorithm described here: https://en.wikipedia.org/wiki/Lab_color_space#Cylindrical_representation:_CIELCh_or_CIEHLC
+            // Conversion algorithm described here:
+            // https://en.wikipedia.org/wiki/Lab_color_space#Cylindrical_representation:_CIELCh_or_CIEHLC
             float l = input.L, a = input.A, b = input.B;
             float c = MathF.Sqrt((a * a) + (b * b));
             float hRadians = MathF.Atan2(b, a);

src/ImageSharp/ColorSpaces/Conversion/Implementation/CieLchuv/CieLchuvToCieLuvConverter.cs

@@ -0,0 +1,34 @@
+// <copyright file="CieLchuvToCieLuvConverter.cs" company="James Jackson-South">
+// Copyright (c) James Jackson-South and contributors.
+// Licensed under the Apache License, Version 2.0.
+// </copyright>
+
+namespace ImageSharp.ColorSpaces.Conversion.Implementation.CieLchuv
+{
+    using System.Runtime.CompilerServices;
+
+    using ImageSharp.ColorSpaces;
+
+    /// <summary>
+    /// Converts from <see cref="CieLch"/> to <see cref="CieLab"/>.
+    /// </summary>
+    internal class CieLchuvToCieLuvConverter : IColorConversion<CieLchuv, CieLuv>
+    {
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public CieLuv Convert(CieLchuv input)
+        {
+            DebugGuard.NotNull(input, nameof(input));
+
+            // Conversion algorithm described here:
+            // https://en.wikipedia.org/wiki/CIELUV#Cylindrical_representation_.28CIELCH.29
+            float l = input.L, c = input.C, hDegrees = input.H;
+            float hRadians = MathF.DegreeToRadian(hDegrees);
+
+            float u = c * MathF.Cos(hRadians);
+            float v = c * MathF.Sin(hRadians);
+
+            return new CieLuv(l, u, v, input.WhitePoint);
+        }
+    }
+}

src/ImageSharp/ColorSpaces/Conversion/Implementation/CieLchuv/CieLuvToCieLchuvConverter.cs

@@ -0,0 +1,42 @@
+// <copyright file="CieLuvToCieLchuvConverter.cs" company="James Jackson-South">
+// Copyright (c) James Jackson-South and contributors.
+// Licensed under the Apache License, Version 2.0.
+// </copyright>
+
+namespace ImageSharp.ColorSpaces.Conversion.Implementation.CieLchuv
+{
+    using System.Runtime.CompilerServices;
+
+    using ImageSharp.ColorSpaces;
+
+    /// <summary>
+    /// Converts from <see cref="CieLab"/> to <see cref="CieLch"/>.
+    /// </summary>
+    internal class CieLuvToCieLchuvConverter : IColorConversion<CieLuv, CieLchuv>
+    {
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public CieLchuv Convert(CieLuv input)
+        {
+            DebugGuard.NotNull(input, nameof(input));
+
+            // Conversion algorithm described here:
+            // https://en.wikipedia.org/wiki/CIELUV#Cylindrical_representation_.28CIELCH.29
+            float l = input.L, a = input.U, b = input.V;
+            float c = MathF.Sqrt((a * a) + (b * b));
+            float hRadians = MathF.Atan2(b, a);
+            float hDegrees = MathF.RadianToDegree(hRadians);
+
+            // Wrap the angle round at 360.
+            hDegrees = hDegrees % 360;
+
+            // Make sure it's not negative.
+            while (hDegrees < 0)
+            {
+                hDegrees += 360;
+            }
+
+            return new CieLchuv(l, c, hDegrees, input.WhitePoint);
+        }
+    }
+}

tests/ImageSharp.Tests/Colorspaces/CieLabAndCieLchConversionTests.cs

@@ -47,7 +47,7 @@
         }
 
         /// <summary>
-        /// Tests conversion from <see cref="LabColor"/> to <see cref="LChabColor"/>.
+        /// Tests conversion from <see cref="CieLab"/> to <see cref="CieLch"/>.
         /// </summary>
         [Theory]
         [InlineData(0, 0, 0, 0, 0, 0)]

tests/ImageSharp.Tests/Colorspaces/CieLuvAndCieLchuvConversionTests.cs

@@ -0,0 +1,77 @@
+namespace ImageSharp.Tests.Colorspaces
+{
+    using System.Collections.Generic;
+    using ImageSharp.ColorSpaces;
+    using ImageSharp.ColorSpaces.Conversion;
+
+    using Xunit;
+
+    /// <summary>
+    /// Tests <see cref="CieLuv"/>-<see cref="CieLchuv"/> conversions.
+    /// </summary>
+    /// <remarks>
+    /// Test data generated using:
+    /// <see href="http://www.brucelindbloom.com/index.html?ColorCalculator.html"/>
+    /// </remarks>
+    public class CieLuvAndCieLchuvuvConversionTests
+    {
+        private static readonly IEqualityComparer<float> FloatRoundingComparer = new FloatRoundingComparer(4);
+
+        private static readonly ColorSpaceConverter Converter = new ColorSpaceConverter();
+
+        /// <summary>
+        /// Tests conversion from <see cref="CieLchuv"/> to <see cref="CieLuv"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0)]
+        [InlineData(54.2917, 106.8391, 40.8526, 54.2917, 80.8125, 69.8851)]
+        [InlineData(100, 0, 0, 100, 0, 0)]
+        [InlineData(100, 50, 180, 100, -50, 0)]
+        [InlineData(10, 36.0555, 56.3099, 10, 20, 30)]
+        [InlineData(10, 36.0555, 56.3099, 10, 20, 30)]
+        [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)
+        {
+            // Arrange
+            CieLchuv input = new CieLchuv(l, c, h);
+
+            // Act
+            CieLuv output = Converter.ToCieLuv(input);
+
+            // Assert
+            Assert.Equal(l2, output.L, FloatRoundingComparer);
+            Assert.Equal(u, output.U, FloatRoundingComparer);
+            Assert.Equal(v, output.V, FloatRoundingComparer);
+        }
+
+        /// <summary>
+        /// Tests conversion from <see cref="CieLuv"/> to <see cref="CieLchuv"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0)]
+        [InlineData(54.2917, 80.8125, 69.8851, 54.2917, 106.8391, 40.8526)]
+        [InlineData(100, 0, 0, 100, 0, 0)]
+        [InlineData(100, -50, 0, 100, 50, 180)]
+        [InlineData(10, 20, 30, 10, 36.0555, 56.3099)]
+        [InlineData(10, 20, 30, 10, 36.0555, 56.3099)]
+        [InlineData(10, -20, 30, 10, 36.0555, 123.6901)]
+        [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)
+        {
+            // Arrange
+            CieLuv input = new CieLuv(l, u, v);
+
+            // Act
+            CieLchuv output = Converter.ToCieLchuv(input);
+
+            // Assert
+            Assert.Equal(l2, output.L, FloatRoundingComparer);
+            Assert.Equal(c, output.C, FloatRoundingComparer);
+            Assert.Equal(h, output.H, FloatRoundingComparer);
+        }
+    }
+}

tests/ImageSharp.Tests/Colorspaces/CieXyzAndCieLabConversionTest.cs

@@ -1,4 +1,4 @@
-namespace ImageSharp.Tests
+namespace ImageSharp.Tests.Colorspaces
 {
     using System.Collections.Generic;
     using ImageSharp.ColorSpaces;

tests/ImageSharp.Tests/Colorspaces/CieXyzAndCieLuvConversionTest.cs

@@ -1,4 +1,4 @@
-namespace ImageSharp.Tests
+namespace ImageSharp.Tests.Colorspaces
 {
     using System.Collections.Generic;
     using ImageSharp.ColorSpaces;

tests/ImageSharp.Tests/Colorspaces/CieXyzAndHunterLabConversionTest.cs

@@ -1,4 +1,4 @@
-namespace ImageSharp.Tests
+namespace ImageSharp.Tests.Colorspaces
 {
     using System.Collections.Generic;
     using ImageSharp.ColorSpaces;

tests/ImageSharp.Tests/Colorspaces/CieXyzAndLmsConversionTest.cs

@@ -1,4 +1,4 @@
-namespace ImageSharp.Tests
+namespace ImageSharp.Tests.Colorspaces
 {
     using System.Collections.Generic;
     using ImageSharp.ColorSpaces;

tests/ImageSharp.Tests/Colorspaces/ColorConverterAdaptTest.cs

@@ -1,4 +1,4 @@
-namespace ImageSharp.Tests
+namespace ImageSharp.Tests.Colorspaces
 {
     using System.Collections.Generic;
 

tests/ImageSharp.Tests/Colorspaces/ColorSpaceEqualityTests.cs

@@ -3,7 +3,7 @@
 // Licensed under the Apache License, Version 2.0.
 // </copyright>
 
-namespace ImageSharp.Tests.Colors
+namespace ImageSharp.Tests.Colorspaces
 {
     using System;
     using System.Numerics;
@@ -21,6 +21,7 @@ namespace ImageSharp.Tests.Colors
                 {
                     CieLab.Empty,
                     CieLch.Empty,
+                    CieLchuv.Empty,
                     CieLuv.Empty,
                     CieXyz.Empty,
                     CieXyy.Empty,
@@ -38,6 +39,7 @@ namespace ImageSharp.Tests.Colors
                {
                { new CieLab(Vector3.One), new CieLab(Vector3.One), typeof(CieLab) },
                { new CieLch(Vector3.One), new CieLch(Vector3.One), typeof(CieLch) },
+               { new CieLchuv(Vector3.One), new CieLchuv(Vector3.One), typeof(CieLchuv) },
                { new CieLuv(Vector3.One), new CieLuv(Vector3.One), typeof(CieLuv) },
                { new CieXyz(Vector3.One), new CieXyz(Vector3.One), typeof(CieXyz) },
                { new CieXyy(Vector3.One), new CieXyy(Vector3.One), typeof(CieXyy) },
@@ -56,6 +58,7 @@ namespace ImageSharp.Tests.Colors
                 // Valid object against null
                { new CieLab(Vector3.One), null, typeof(CieLab) },
                { new CieLch(Vector3.One), null, typeof(CieLch) },
+               { new CieLchuv(Vector3.One), null, typeof(CieLchuv) },
                { new CieLuv(Vector3.One), null, typeof(CieLuv) },
                { new CieXyz(Vector3.One), null, typeof(CieXyz) },
                { new CieXyy(Vector3.One), null, typeof(CieXyy) },
@@ -73,7 +76,7 @@ namespace ImageSharp.Tests.Colors
                {
                 // Valid objects of different types but not equal
                 { new CieLab(Vector3.One), new CieLch(Vector3.Zero), null },
-                { new CieLuv(Vector3.One), new CieLuv(Vector3.Zero), null },
+                { new CieLuv(Vector3.One), new CieLchuv(Vector3.Zero), null },
                 { new CieXyz(Vector3.One), new HunterLab(Vector3.Zero), null },
                 { new Rgb(Vector3.One), new LinearRgb(Vector3.Zero), null },
                 { new Rgb(Vector3.One), new Lms(Vector3.Zero), null },
@@ -88,6 +91,7 @@ namespace ImageSharp.Tests.Colors
                 // Valid objects of the same type but not equal
                { new CieLab(Vector3.One), new CieLab(Vector3.Zero), typeof(CieLab) },
                { new CieLch(Vector3.One), new CieLch(Vector3.Zero), typeof(CieLch) },
+               { new CieLchuv(Vector3.One), new CieLchuv(Vector3.Zero), typeof(CieLchuv) },
                { new CieLuv(Vector3.One), new CieLuv(Vector3.Zero), typeof(CieLuv) },
                { new CieXyz(Vector3.One), new CieXyz(Vector3.Zero), typeof(CieXyz) },
                { new CieXyy(Vector3.One), new CieXyy(Vector3.Zero), typeof(CieXyy) },
@@ -112,6 +116,7 @@ namespace ImageSharp.Tests.Colors
                 { new CieLab(0F, 0F, 0F), new CieLab(0F, 0F, .0001F), typeof(CieLab), .0001F },
                 { new CieLab(0F, 0F, 0F), new CieLab(.0005F, 0F, 0F), typeof(CieLab), .0005F },
                 { new CieLch(0F, 0F, 0F), new CieLch(0F, .001F, 0F), typeof(CieLch), .001F },
+                { new CieLchuv(0F, 0F, 0F), new CieLchuv(0F, .001F, 0F), typeof(CieLchuv), .001F },
                 { new CieLuv(0F, 0F, 0F), new CieLuv(0F, .001F, 0F), typeof(CieLuv), .001F },
                 { new CieXyz(380F, 380F, 380F), new CieXyz(380F, 380F, 380F), typeof(CieXyz), 0F },
                 { new CieXyz(380F, 380F, 380F), new CieXyz(380.001F, 380F, 380F), typeof(CieXyz), .01F },

tests/ImageSharp.Tests/Colorspaces/RgbAndCieXyzConversionTest.cs

@@ -1,4 +1,4 @@
-namespace ImageSharp.Tests
+namespace ImageSharp.Tests.Colorspaces
 {
     using System.Collections.Generic;
     using ImageSharp.ColorSpaces;