Add Hsv

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

@@ -98,6 +98,19 @@ namespace ImageSharp.ColorSpaces.Conversion
             return this.ToCieLab(xyzColor);
         }
 
+        /// <summary>
+        /// Converts a <see cref="Hsv"/> into a <see cref="CieLab"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="CieLab"/></returns>
+        public CieLab ToCieLab(Hsv color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+            return this.ToCieLab(xyzColor);
+        }
+
         /// <summary>
         /// Converts a <see cref="HunterLab"/> into a <see cref="CieLab"/>
         /// </summary>

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

@@ -85,6 +85,19 @@ namespace ImageSharp.ColorSpaces.Conversion
             return this.ToCieLch(xyzColor);
         }
 
+        /// <summary>
+        /// Converts a <see cref="Hsv"/> into a <see cref="CieLch"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="CieLch"/></returns>
+        public CieLch ToCieLch(Hsv color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+            return this.ToCieLch(xyzColor);
+        }
+
         /// <summary>
         /// Converts a <see cref="HunterLab"/> into a <see cref="CieLch"/>
         /// </summary>

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

@@ -82,6 +82,20 @@ namespace ImageSharp.ColorSpaces.Conversion
             return this.ToCieXyy(xyzColor);
         }
 
+        /// <summary>
+        /// Converts a <see cref="Hsv"/> into a <see cref="CieXyy"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="CieXyy"/></returns>
+        public CieXyy ToCieXyy(Hsv color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+
+            return this.ToCieXyy(xyzColor);
+        }
+
         /// <summary>
         /// Converts a <see cref="HunterLab"/> into a <see cref="CieXyy"/>
         /// </summary>

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

@@ -100,6 +100,21 @@ namespace ImageSharp.ColorSpaces.Conversion
             return this.ToCieXyz(rgb);
         }
 
+        /// <summary>
+        /// Converts a <see cref="Hsv"/> into a <see cref="CieXyz"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="CieXyz"/></returns>
+        public CieXyz ToCieXyz(Hsv color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            // Conversion
+            Rgb rgb = this.ToRgb(color);
+
+            return this.ToCieXyz(rgb);
+        }
+
         /// <summary>
         /// Converts a <see cref="HunterLab"/> into a <see cref="CieXyz"/>
         /// </summary>

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

@@ -85,6 +85,20 @@ namespace ImageSharp.ColorSpaces.Conversion
             return CmykAndRgbConverter.Convert(rgb);
         }
 
+        /// <summary>
+        /// Converts a <see cref="Hsv"/> into a <see cref="Cmyk"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="Cmyk"/></returns>
+        public Cmyk ToCmyk(Hsv color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            Rgb rgb = this.ToRgb(color);
+
+            return CmykAndRgbConverter.Convert(rgb);
+        }
+
         /// <summary>
         /// Converts a <see cref="HunterLab"/> into a <see cref="Cmyk"/>
         /// </summary>

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

@@ -85,6 +85,20 @@ namespace ImageSharp.ColorSpaces.Conversion
             return HslAndRgbConverter.Convert(rgb);
         }
 
+        /// <summary>
+        /// Converts a <see cref="Hsv"/> into a <see cref="Hsl"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="Hsl"/></returns>
+        public Hsl ToHsl(Hsv color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            Rgb rgb = this.ToRgb(color);
+
+            return HslAndRgbConverter.Convert(rgb);
+        }
+
         /// <summary>
         /// Converts a <see cref="HunterLab"/> into a <see cref="Hsl"/>
         /// </summary>

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

@@ -0,0 +1,170 @@
+// <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;
+    using ImageSharp.ColorSpaces.Conversion.Implementation.Hsv;
+
+    /// <summary>
+    /// Converts between color spaces ensuring that the color is adapted using chromatic adaptation.
+    /// </summary>
+    public partial class ColorSpaceConverter
+    {
+        private static readonly HsvAndRgbConverter HsvAndRgbConverter = new HsvAndRgbConverter();
+
+        /// <summary>
+        /// Converts a <see cref="CieLab"/> into a <see cref="Hsv"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="Hsv"/></returns>
+        public Hsv ToHsv(CieLab color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+
+            return this.ToHsv(xyzColor);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="CieLch"/> into a <see cref="Hsv"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="Hsv"/></returns>
+        public Hsv ToHsv(CieLch color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+
+            return this.ToHsv(xyzColor);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="CieXyy"/> into a <see cref="Hsv"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="Hsv"/></returns>
+        public Hsv ToHsv(CieXyy color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+
+            return this.ToHsv(xyzColor);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="CieXyz"/> into a <see cref="Hsv"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="Hsv"/></returns>
+        public Hsv ToHsv(CieXyz color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            Rgb rgb = this.ToRgb(color);
+
+            return HsvAndRgbConverter.Convert(rgb);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="Cmyk"/> into a <see cref="Hsv"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="Hsv"/></returns>
+        public Hsv ToHsv(Cmyk color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            Rgb rgb = this.ToRgb(color);
+
+            return HsvAndRgbConverter.Convert(rgb);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="Hsl"/> into a <see cref="Hsv"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="Hsv"/></returns>
+        public Hsv ToHsv(Hsl color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            Rgb rgb = this.ToRgb(color);
+
+            return HsvAndRgbConverter.Convert(rgb);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="HunterLab"/> into a <see cref="Hsv"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="Hsv"/></returns>
+        public Hsv ToHsv(HunterLab color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+
+            return this.ToHsv(xyzColor);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="LinearRgb"/> into a <see cref="Hsv"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="Hsv"/></returns>
+        public Hsv ToHsv(LinearRgb color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            Rgb rgb = this.ToRgb(color);
+
+            return HsvAndRgbConverter.Convert(rgb);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="Lms"/> into a <see cref="Hsv"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="Hsv"/></returns>
+        public Hsv ToHsv(Lms color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+
+            return this.ToHsv(xyzColor);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="Rgb"/> into a <see cref="Hsv"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="Hsv"/></returns>
+        public Hsv ToHsv(Rgb color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            return HsvAndRgbConverter.Convert(color);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="YCbCr"/> into a <see cref="Hsv"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="Hsv"/></returns>
+        public Hsv ToHsv(YCbCr color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            Rgb rgb = this.ToRgb(color);
+
+            return HsvAndRgbConverter.Convert(rgb);
+        }
+    }
+}

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

@@ -95,6 +95,19 @@ namespace ImageSharp.ColorSpaces.Conversion
             return this.ToHunterLab(xyzColor);
         }
 
+        /// <summary>
+        /// Converts a <see cref="Hsv"/> into a <see cref="HunterLab"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="HunterLab"/></returns>
+        public HunterLab ToHunterLab(Hsv color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+            return this.ToHunterLab(xyzColor);
+        }
+
         /// <summary>
         /// Converts a <see cref="LinearRgb"/> into a <see cref="HunterLab"/>
         /// </summary>

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

@@ -100,6 +100,19 @@ namespace ImageSharp.ColorSpaces.Conversion
             return this.ToLinearRgb(rgb);
         }
 
+        /// <summary>
+        /// Converts a <see cref="Hsv"/> into a <see cref="LinearRgb"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="LinearRgb"/></returns>
+        public LinearRgb ToLinearRgb(Hsv color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            Rgb rgb = this.ToRgb(color);
+            return this.ToLinearRgb(rgb);
+        }
+
         /// <summary>
         /// Converts a <see cref="HunterLab"/> into a <see cref="LinearRgb"/>
         /// </summary>

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

@@ -90,6 +90,19 @@ namespace ImageSharp.ColorSpaces.Conversion
             return this.ToLms(xyzColor);
         }
 
+        /// <summary>
+        /// Converts a <see cref="Hsv"/> into a <see cref="Lms"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="Lms"/></returns>
+        public Lms ToLms(Hsv color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            CieXyz xyzColor = this.ToCieXyz(color);
+            return this.ToLms(xyzColor);
+        }
+
         /// <summary>
         /// Converts a <see cref="HunterLab"/> into a <see cref="Lms"/>
         /// </summary>

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

@@ -82,6 +82,19 @@ namespace ImageSharp.ColorSpaces.Conversion
             return CmykAndRgbConverter.Convert(color);
         }
 
+        /// <summary>
+        /// Converts a <see cref="Hsv"/> into a <see cref="Rgb"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="Rgb"/></returns>
+        public Rgb ToRgb(Hsv color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            // Conversion
+            return HsvAndRgbConverter.Convert(color);
+        }
+
         /// <summary>
         /// Converts a <see cref="Hsl"/> into a <see cref="Rgb"/>
         /// </summary>

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

@@ -99,6 +99,20 @@ namespace ImageSharp.ColorSpaces.Conversion
             return YCbCrAndRgbConverter.Convert(rgb);
         }
 
+        /// <summary>
+        /// Converts a <see cref="Hsv"/> into a <see cref="YCbCr"/>
+        /// </summary>
+        /// <param name="color">The color to convert.</param>
+        /// <returns>The <see cref="YCbCr"/></returns>
+        public YCbCr ToYCbCr(Hsv color)
+        {
+            Guard.NotNull(color, nameof(color));
+
+            Rgb rgb = this.ToRgb(color);
+
+            return YCbCrAndRgbConverter.Convert(rgb);
+        }
+
         /// <summary>
         /// Converts a <see cref="HunterLab"/> into a <see cref="YCbCr"/>
         /// </summary>

src/ImageSharp/ColorSpaces/Conversion/Implementation/Hsv/HsvAndRgbConverter.cs

@@ -0,0 +1,130 @@
+// <copyright file="HsvAndRgbConverter.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.Hsv
+{
+    using System;
+    using System.Runtime.CompilerServices;
+
+    using ImageSharp.ColorSpaces;
+
+    /// <summary>
+    /// Color converter between HSV and Rgb
+    /// See <see href="http://www.poynton.com/PDFs/coloureq.pdf"/> for formulas.
+    /// </summary>
+    internal class HsvAndRgbConverter : IColorConversion<Hsv, Rgb>, IColorConversion<Rgb, Hsv>
+    {
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Rgb Convert(Hsv input)
+        {
+            DebugGuard.NotNull(input, nameof(input));
+
+            float s = input.S;
+            float v = input.V;
+
+            if (MathF.Abs(s) < Constants.Epsilon)
+            {
+                return new Rgb(v, v, v);
+            }
+
+            float h = (MathF.Abs(input.H - 360) < Constants.Epsilon) ? 0 : input.H / 60;
+            int i = (int)Math.Truncate(h);
+            float f = h - i;
+
+            float p = v * (1F - s);
+            float q = v * (1F - (s * f));
+            float t = v * (1F - (s * (1F - f)));
+
+            float r, g, b;
+            switch (i)
+            {
+                case 0:
+                    r = v;
+                    g = t;
+                    b = p;
+                    break;
+
+                case 1:
+                    r = q;
+                    g = v;
+                    b = p;
+                    break;
+
+                case 2:
+                    r = p;
+                    g = v;
+                    b = t;
+                    break;
+
+                case 3:
+                    r = p;
+                    g = q;
+                    b = v;
+                    break;
+
+                case 4:
+                    r = t;
+                    g = p;
+                    b = v;
+                    break;
+
+                default:
+                    r = v;
+                    g = p;
+                    b = q;
+                    break;
+            }
+
+            return new Rgb(r, g, b);
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Hsv Convert(Rgb input)
+        {
+            DebugGuard.NotNull(input, nameof(input));
+
+            float r = input.R;
+            float g = input.G;
+            float b = input.B;
+
+            float max = MathF.Max(r, MathF.Max(g, b));
+            float min = MathF.Min(r, MathF.Min(g, b));
+            float chroma = max - min;
+            float h = 0;
+            float s = 0;
+            float v = max;
+
+            if (MathF.Abs(chroma) < Constants.Epsilon)
+            {
+                return new Hsv(0, s, v);
+            }
+
+            if (MathF.Abs(r - max) < Constants.Epsilon)
+            {
+                h = (g - b) / chroma;
+            }
+            else if (MathF.Abs(g - max) < Constants.Epsilon)
+            {
+                h = 2 + ((b - r) / chroma);
+            }
+            else if (MathF.Abs(b - max) < Constants.Epsilon)
+            {
+                h = 4 + ((r - g) / chroma);
+            }
+
+            h *= 60;
+            if (h < 0.0)
+            {
+                h += 360;
+            }
+
+            s = chroma / v;
+
+            return new Hsv(h, s, v);
+        }
+    }
+}

src/ImageSharp/ColorSpaces/Hsv.cs

@@ -0,0 +1,233 @@
+// <copyright file="Hsv.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;
+
+    using ImageSharp.PixelFormats;
+
+    /// <summary>
+    /// Represents a HSV (hue, saturation, value) color. Also known as HSB (hue, saturation, brightness).
+    /// </summary>
+    public struct Hsv : IColorVector, IEquatable<Hsv>, IAlmostEquatable<Hsv, float>
+    {
+        /// <summary>
+        /// Represents a <see cref="Hsv"/> that has H, S, and V values set to zero.
+        /// </summary>
+        public static readonly Hsv Empty = default(Hsv);
+
+        /// <summary>
+        /// Max range used for clamping
+        /// </summary>
+        private static readonly Vector3 VectorMax = new Vector3(360, 1, 1);
+
+        /// <summary>
+        /// The backing vector for SIMD support.
+        /// </summary>
+        private readonly Vector3 backingVector;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Hsv"/> struct.
+        /// </summary>
+        /// <param name="h">The h hue component.</param>
+        /// <param name="s">The s saturation component.</param>
+        /// <param name="v">The v value (brightness) component.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Hsv(float h, float s, float v)
+            : this(new Vector3(h, s, v))
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Hsv"/> struct.
+        /// </summary>
+        /// <param name="vector">The vector representing the h, s, v components.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Hsv(Vector3 vector)
+        {
+            this.backingVector = Vector3.Clamp(vector, Vector3.Zero, VectorMax);
+        }
+
+        /// <summary>
+        /// Gets the hue component.
+        /// <remarks>A value ranging between 0 and 360.</remarks>
+        /// </summary>
+        public float H
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => this.backingVector.X;
+        }
+
+        /// <summary>
+        /// Gets the saturation component.
+        /// <remarks>A value ranging between 0 and 1.</remarks>
+        /// </summary>
+        public float S
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => this.backingVector.Y;
+        }
+
+        /// <summary>
+        /// Gets the value (brightness) component.
+        /// <remarks>A value ranging between 0 and 1.</remarks>
+        /// </summary>
+        public float V
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => this.backingVector.Z;
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether this <see cref="Hsv"/> is empty.
+        /// </summary>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public bool IsEmpty => this.Equals(Empty);
+
+        /// <inheritdoc/>
+        public Vector3 Vector
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => this.backingVector;
+        }
+
+        /// <summary>
+        /// Allows the implicit conversion of an instance of <see cref="Rgba32"/> to a
+        /// <see cref="Hsv"/>.
+        /// </summary>
+        /// <param name="color">The instance of <see cref="Rgba32"/> to convert.</param>
+        /// <returns>
+        /// An instance of <see cref="Hsv"/>.
+        /// </returns>
+        public static implicit operator Hsv(Rgba32 color)
+        {
+            float r = color.R / 255F;
+            float g = color.G / 255F;
+            float b = color.B / 255F;
+
+            float max = MathF.Max(r, MathF.Max(g, b));
+            float min = MathF.Min(r, MathF.Min(g, b));
+            float chroma = max - min;
+            float h = 0;
+            float s = 0;
+            float v = max;
+
+            if (MathF.Abs(chroma) < Constants.Epsilon)
+            {
+                return new Hsv(0, s, v);
+            }
+
+            if (MathF.Abs(r - max) < Constants.Epsilon)
+            {
+                h = (g - b) / chroma;
+            }
+            else if (MathF.Abs(g - max) < Constants.Epsilon)
+            {
+                h = 2 + ((b - r) / chroma);
+            }
+            else if (MathF.Abs(b - max) < Constants.Epsilon)
+            {
+                h = 4 + ((r - g) / chroma);
+            }
+
+            h *= 60;
+            if (h < 0.0)
+            {
+                h += 360;
+            }
+
+            s = chroma / v;
+
+            return new Hsv(h, s, v);
+        }
+
+        /// <summary>
+        /// Compares two <see cref="Hsv"/> objects for equality.
+        /// </summary>
+        /// <param name="left">
+        /// The <see cref="Hsv"/> on the left side of the operand.
+        /// </param>
+        /// <param name="right">
+        /// The <see cref="Hsv"/> 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 ==(Hsv left, Hsv right)
+        {
+            return left.Equals(right);
+        }
+
+        /// <summary>
+        /// Compares two <see cref="Hsv"/> objects for inequality.
+        /// </summary>
+        /// <param name="left">
+        /// The <see cref="Hsv"/> on the left side of the operand.
+        /// </param>
+        /// <param name="right">
+        /// The <see cref="Hsv"/> 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 !=(Hsv left, Hsv right)
+        {
+            return !left.Equals(right);
+        }
+
+        /// <inheritdoc/>
+        public override int GetHashCode()
+        {
+            return this.backingVector.GetHashCode();
+        }
+
+        /// <inheritdoc/>
+        public override string ToString()
+        {
+            if (this.IsEmpty)
+            {
+                return "Hsv [ Empty ]";
+            }
+
+            return $"Hsv [ H={this.H:#0.##}, S={this.S:#0.##}, V={this.V:#0.##} ]";
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override bool Equals(object obj)
+        {
+            if (obj is Hsv)
+            {
+                return this.Equals((Hsv)obj);
+            }
+
+            return false;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(Hsv other)
+        {
+            return this.backingVector.Equals(other.backingVector);
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool AlmostEquals(Hsv other, float precision)
+        {
+            Vector3 result = Vector3.Abs(this.backingVector - other.backingVector);
+
+            return result.X <= precision
+                && result.Y <= precision
+                && result.Z <= precision;
+        }
+    }
+}

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

@@ -23,11 +23,12 @@ namespace ImageSharp.Tests.Colors
                     CieLch.Empty,
                     CieXyz.Empty,
                     CieXyy.Empty,
+                    Hsl.Empty,
+                    Hsl.Empty,
                     HunterLab.Empty,
                     Lms.Empty,
                     LinearRgb.Empty,
                     Rgb.Empty,
-                    Hsl.Empty,
                     YCbCr.Empty
                 };
 
@@ -43,6 +44,7 @@ namespace ImageSharp.Tests.Colors
                { new LinearRgb(Vector3.One), new LinearRgb(Vector3.One), typeof(LinearRgb) },
                { new Rgb(Vector3.One), new Rgb(Vector3.One), typeof(Rgb) },
                { new Hsl(Vector3.One), new Hsl(Vector3.One), typeof(Hsl) },
+               { new Hsv(Vector3.One), new Hsv(Vector3.One), typeof(Hsl) },
                { new YCbCr(Vector3.One), new YCbCr(Vector3.One), typeof(YCbCr) },
            };
 
@@ -59,6 +61,7 @@ namespace ImageSharp.Tests.Colors
                { new LinearRgb(Vector3.One), null, typeof(LinearRgb) },
                { new Rgb(Vector3.One), null, typeof(Rgb) },
                { new Hsl(Vector3.One), null, typeof(Hsl) },
+               { new Hsv(Vector3.One), null, typeof(Hsv) },
                { new YCbCr(Vector3.One), null, typeof(YCbCr) },
             };
 
@@ -72,6 +75,7 @@ namespace ImageSharp.Tests.Colors
                 { new Rgb(Vector3.One), new Lms(Vector3.Zero), null },
                 { new Cmyk(Vector4.One), new Hsl(Vector3.Zero), null },
                 { new YCbCr(Vector3.One), new CieXyy(Vector3.Zero), null },
+                { new Hsv(Vector3.One), new Hsl(Vector3.Zero), null },
            };
 
         public static readonly TheoryData<object, object, Type> NotEqualityData =
@@ -88,6 +92,7 @@ namespace ImageSharp.Tests.Colors
                { new Rgb(Vector3.One), new Rgb(Vector3.Zero), typeof(Rgb) },
                { new Cmyk(Vector4.One), new Cmyk(Vector4.Zero), typeof(Cmyk) },
                { new Hsl(Vector3.One), new Hsl(Vector3.Zero), typeof(Hsl) },
+               { new Hsv(Vector3.One), new Hsv(Vector3.Zero), typeof(YCbCr) },
                { new YCbCr(Vector3.One), new YCbCr(Vector3.Zero), typeof(YCbCr) },
            };
 
@@ -107,6 +112,8 @@ namespace ImageSharp.Tests.Colors
                 { new CieXyz(380F, 380F, 380F), new CieXyz(380F, 380F, 380.001F), typeof(CieXyz), .01F },
                 { new Cmyk(1, 1, 1, 1), new Cmyk(1, 1, 1, .99F), typeof(Cmyk), .01F },
                 { new YCbCr(255F, 128F, 128F), new YCbCr(255F, 128F, 128.001F), typeof(YCbCr), .01F },
+                { new Hsv(0F, 0F, 0F), new Hsv(0F, 0F, 0F), typeof(Hsv), 0F },
+                { new Hsl(0F, 0F, 0F), new Hsl(0F, 0F, 0F), typeof(Hsl), 0F },
             };
 
         public static readonly TheoryData<object, object, Type, float> AlmostNotEqualsData =

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

@@ -0,0 +1,71 @@
+namespace ImageSharp.Tests.Colors.Colorspaces
+{
+    using System.Collections.Generic;
+
+    using ImageSharp.ColorSpaces;
+    using ImageSharp.ColorSpaces.Conversion;
+
+    using Xunit;
+
+    /// <summary>
+    /// Tests <see cref="Rgb"/>-<see cref="Hsv"/> conversions.
+    /// </summary>
+    /// <remarks>
+    /// Test data generated using:
+    /// <see href="http://www.colorhexa.com"/>
+    /// </remarks>
+    public class RgbAndHsvConversionTest
+    {
+        private static readonly IEqualityComparer<float> FloatRoundingComparer = new FloatRoundingComparer(4);
+
+        private static readonly ColorSpaceConverter Converter = new ColorSpaceConverter();
+
+        /// <summary>
+        /// Tests conversion from <see cref="Hsv"/> to <see cref="Rgb"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0)]
+        [InlineData(0, 0, 1, 1, 1, 1)]
+        [InlineData(360, 1, 1, 1, 0, 0)]
+        [InlineData(0, 1, 1, 1, 0, 0)]
+        [InlineData(120, 1, 1, 0, 1, 0)]
+        [InlineData(240, 1, 1, 0, 0, 1)]
+        public void Convert_Hsv_To_Rgb(float h, float s, float v, float r, float g, float b)
+        {
+            // Arrange
+            Hsv input = new Hsv(h, s, v);
+
+            // Act
+            Rgb output = Converter.ToRgb(input);
+
+            // Assert
+            Assert.Equal(Rgb.DefaultWorkingSpace, output.WorkingSpace);
+            Assert.Equal(r, output.R, FloatRoundingComparer);
+            Assert.Equal(g, output.G, FloatRoundingComparer);
+            Assert.Equal(b, output.B, FloatRoundingComparer);
+        }
+
+        /// <summary>
+        /// Tests conversion from <see cref="Rgb"/> to <see cref="Hsv"/>.
+        /// </summary>
+        [Theory]
+        [InlineData(0, 0, 0, 0, 0, 0)]
+        [InlineData(1, 1, 1, 0, 0, 1)]
+        [InlineData(1, 0, 0, 0, 1, 1)]
+        [InlineData(0, 1, 0, 120, 1, 1)]
+        [InlineData(0, 0, 1, 240, 1, 1)]
+        public void Convert_Rgb_To_Hsv(float r, float g, float b, float h, float s, float v)
+        {
+            // Arrange
+            Rgb input = new Rgb(r, g, b);
+
+            // Act
+            Hsv output = Converter.ToHsv(input);
+
+            // Assert
+            Assert.Equal(h, output.H, FloatRoundingComparer);
+            Assert.Equal(s, output.S, FloatRoundingComparer);
+            Assert.Equal(v, output.V, FloatRoundingComparer);
+        }
+    }
+}