DarthAffe/RGB.NET
1
0
Fork 0
mirror of https://github.com/DarthAffe/RGB.NET.git synced 2025-12-12 17:48:31 +00:00
Code Issues Releases Wiki Activity

Merge

Browse Source
This commit is contained in:
Darth Affe 2019-03-31 12:24:17 +02:00
commit 751ca0afa9
33 changed files with 2110 additions and 1174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
RGB.NET.Brushes/Gradients/LinearGradient.cs
View File

@ -97,10 +97,10 @@ namespace RGB.NET.Brushes.Gradients
if (!gsBefore.Offset.Equals(gsAfter.Offset))
blendFactor = ((offset - gsBefore.Offset) / (gsAfter.Offset - gsBefore.Offset));
byte colA = (byte)(((gsAfter.Color.A - gsBefore.Color.A) * blendFactor) + gsBefore.Color.A);
byte colR = (byte)(((gsAfter.Color.R - gsBefore.Color.R) * blendFactor) + gsBefore.Color.R);
byte colG = (byte)(((gsAfter.Color.G - gsBefore.Color.G) * blendFactor) + gsBefore.Color.G);
byte colB = (byte)(((gsAfter.Color.B - gsBefore.Color.B) * blendFactor) + gsBefore.Color.B);
double colA = ((gsAfter.Color.A - gsBefore.Color.A) * blendFactor) + gsBefore.Color.A;
double colR = ((gsAfter.Color.R - gsBefore.Color.R) * blendFactor) + gsBefore.Color.R;
double colG = ((gsAfter.Color.G - gsBefore.Color.G) * blendFactor) + gsBefore.Color.G;
double colB = ((gsAfter.Color.B - gsBefore.Color.B) * blendFactor) + gsBefore.Color.B;
return new Color(colA, colR, colG, colB);
}

8
RGB.NET.Brushes/Gradients/RainbowGradient.cs
View File

@ -73,10 +73,8 @@ namespace RGB.NET.Brushes.Gradients
public Color GetColor(double offset)
{
double range = EndHue - StartHue;
double hue = (StartHue + (range * offset)) % 360f;
if (hue < 0)
hue += 360;
return Color.FromHSV(hue, 1, 1);
double hue = StartHue + (range * offset);
return HSVColor.Create(hue, 1, 1);
}
/// <inheritdoc />
@ -87,7 +85,7 @@ namespace RGB.NET.Brushes.Gradients
StartHue += offset;
EndHue += offset;
while ((StartHue > 360) && (EndHue > 360))
{
StartHue -= 360;

2
RGB.NET.Core/Brushes/AbstractBrush.cs
View File

@ -115,7 +115,7 @@ namespace RGB.NET.Core
// Since we use HSV to calculate there is no way to make a color 'brighter' than 100%
// Be carefull with the naming: Since we use HSV the correct term is 'value' but outside we call it 'brightness'
// THIS IS NOT A HSB CALCULATION!!!
return color.MultiplyValue(Brightness.Clamp(0, 1))
return color.MultiplyHSV(value: Brightness.Clamp(0, 1))
.MultiplyA(Opacity.Clamp(0, 1));
}

80
RGB.NET.Core/Color/Behaviors/DefaultColorBehavior.cs Normal file
View File

@ -0,0 +1,80 @@
namespace RGB.NET.Core
{
public class DefaultColorBehavior : IColorBehavior
{
#region Properties & Fields
private static DefaultColorBehavior _instance = new DefaultColorBehavior();
/// <summary>
/// Gets the singleton instance of <see cref="DefaultColorBehavior"/>.
/// </summary>
public static DefaultColorBehavior Instance { get; } = _instance;
#endregion
#region Constructors
private DefaultColorBehavior()
{ }
#endregion
#region Methods
/// <summary>
/// Converts the individual byte values of this <see cref="Color"/> to a human-readable string.
/// </summary>
/// <returns>A string that contains the individual byte values of this <see cref="Color"/>. For example "[A: 255, R: 255, G: 0, B: 0]".</returns>
public virtual string ToString(Color color) => $"[A: {color.GetA()}, R: {color.GetR()}, G: {color.GetG()}, B: {color.GetB()}]";
/// <summary>
/// Tests whether the specified object is a <see cref="Color" /> and is equivalent to this <see cref="Color" />.
/// </summary>
/// <param name="obj">The object to test.</param>
/// <returns><c>true</c> if <paramref name="obj" /> is a <see cref="Color" /> equivalent to this <see cref="Color" />; otherwise, <c>false</c>.</returns>
public virtual bool Equals(Color color, object obj)
{
if (!(obj is Color)) return false;
(double a, double r, double g, double b) = ((Color)obj).GetRGB();
return color.A.EqualsInTolerance(a) && color.R.EqualsInTolerance(r) && color.G.EqualsInTolerance(g) && color.B.EqualsInTolerance(b);
}
/// <summary>
/// Returns a hash code for this <see cref="Color" />.
/// </summary>
/// <returns>An integer value that specifies the hash code for this <see cref="Color" />.</returns>
public virtual int GetHashCode(Color color)
{
unchecked
{
int hashCode = color.A.GetHashCode();
hashCode = (hashCode * 397) ^ color.R.GetHashCode();
hashCode = (hashCode * 397) ^ color.G.GetHashCode();
hashCode = (hashCode * 397) ^ color.B.GetHashCode();
return hashCode;
}
}
/// <summary>
/// Blends a <see cref="Color"/> over this color.
/// </summary>
/// <param name="color">The <see cref="Color"/> to blend.</param>
public virtual Color Blend(Color baseColor, Color blendColor)
{
if (blendColor.A.EqualsInTolerance(0)) return baseColor;
if (blendColor.A.EqualsInTolerance(1))
return blendColor;
double resultA = (1.0 - ((1.0 - blendColor.A) * (1.0 - baseColor.A)));
double resultR = (((blendColor.R * blendColor.A) / resultA) + ((baseColor.R * baseColor.A * (1.0 - blendColor.A)) / resultA));
double resultG = (((blendColor.G * blendColor.A) / resultA) + ((baseColor.G * baseColor.A * (1.0 - blendColor.A)) / resultA));
double resultB = (((blendColor.B * blendColor.A) / resultA) + ((baseColor.B * baseColor.A * (1.0 - blendColor.A)) / resultA));
return new Color(resultA, resultR, resultG, resultB);
}
#endregion
}
}

13
RGB.NET.Core/Color/Behaviors/IColorBehavior.cs Normal file
View File

@ -0,0 +1,13 @@
namespace RGB.NET.Core
{
public interface IColorBehavior
{
string ToString(Color color);
bool Equals(Color color, object obj);
int GetHashCode(Color color);
Color Blend(Color baseColor, Color blendColor);
}
}

288
RGB.NET.Core/Color/Color.cs Normal file
View File

@ -0,0 +1,288 @@
// ReSharper disable MemberCanBePrivate.Global
// ReSharper disable UnusedMember.Global
// ReSharper disable UnusedMethodReturnValue.Global
using System;
using System.Diagnostics;
namespace RGB.NET.Core
{
/// <inheritdoc />
/// <summary>
/// Represents an ARGB (alpha, red, green, blue) color.
/// </summary>
[DebuggerDisplay("[A: {A}, R: {R}, G: {G}, B: {B}]")]
public struct Color
{
#region Constants
/// <summary>
/// Gets an transparent color [A: 0, R: 0, G: 0, B: 0]
/// </summary>
public static Color Transparent => new Color(0, 0, 0, 0);
#endregion
#region Properties & Fields
private static IColorBehavior _behavior = DefaultColorBehavior.Instance;
/// <summary>
/// Gets or sets the <see cref="IColorBehavior"/> used to perform operations on colors.
/// </summary>
public static IColorBehavior Behavior
{
get => _behavior;
set => _behavior = value ?? DefaultColorBehavior.Instance;
}
/// <summary>
/// Gets the alpha component value of this <see cref="Color"/> as percentage in the range [0..1].
/// </summary>
public double A { get; }
/// <summary>
/// Gets the red component value of this <see cref="Color"/> as percentage in the range [0..1].
/// </summary>
public double R { get; }
/// <summary>
/// Gets the green component value of this <see cref="Color"/> as percentage in the range [0..1].
/// </summary>
public double G { get; }
/// <summary>
/// Gets the blue component value of this <see cref="Color"/> as percentage in the range [0..1].
/// </summary>
public double B { get; }
#endregion
#region Constructors
/// <inheritdoc />
/// <summary>
/// Initializes a new instance of the <see cref="T:RGB.NET.Core.Color" /> struct using RGB-Values.
/// Alpha defaults to 255.
/// </summary>
/// <param name="r">The red component value of this <see cref="T:RGB.NET.Core.Color" />.</param>
/// <param name="g">The green component value of this <see cref="T:RGB.NET.Core.Color" />.</param>
/// <param name="b">The blue component value of this <see cref="T:RGB.NET.Core.Color" />.</param>
public Color(byte r, byte g, byte b)
: this(byte.MaxValue, r, g, b)
{ }
/// <inheritdoc />
/// <summary>
/// Initializes a new instance of the <see cref="T:RGB.NET.Core.Color" /> struct using RGB-Values.
/// Alpha defaults to 255.
/// </summary>
/// <param name="r">The red component value of this <see cref="T:RGB.NET.Core.Color" />.</param>
/// <param name="g">The green component value of this <see cref="T:RGB.NET.Core.Color" />.</param>
/// <param name="b">The blue component value of this <see cref="T:RGB.NET.Core.Color" />.</param>
public Color(int r, int g, int b)
: this((byte)r.Clamp(0, byte.MaxValue), (byte)g.Clamp(0, byte.MaxValue), (byte)b.Clamp(0, byte.MaxValue))
{ }
/// <summary>
/// Initializes a new instance of the <see cref="Color"/> struct using ARGB values.
/// </summary>
/// <param name="a">The alpha component value of this <see cref="Color"/>.</param>
/// <param name="r">The red component value of this <see cref="Color"/>.</param>
/// <param name="g">The green component value of this <see cref="Color"/>.</param>
/// <param name="b">The blue component value of this <see cref="Color"/>.</param>
public Color(byte a, byte r, byte g, byte b)
: this(a.GetPercentageFromByteValue(), r.GetPercentageFromByteValue(), g.GetPercentageFromByteValue(), b.GetPercentageFromByteValue())
{ }
/// <summary>
/// Initializes a new instance of the <see cref="Color"/> struct using ARGB values.
/// </summary>
/// <param name="a">The alpha component value of this <see cref="Color"/>.</param>
/// <param name="r">The red component value of this <see cref="Color"/>.</param>
/// <param name="g">The green component value of this <see cref="Color"/>.</param>
/// <param name="b">The blue component value of this <see cref="Color"/>.</param>
public Color(int a, int r, int g, int b)
: this((byte)a.Clamp(0, byte.MaxValue), (byte)r.Clamp(0, byte.MaxValue), (byte)g.Clamp(0, byte.MaxValue), (byte)b.Clamp(0, byte.MaxValue))
{ }
/// <summary>
/// Initializes a new instance of the <see cref="Color"/> struct using RGB-percent values.
/// Alpha defaults to 1.0.
/// </summary>
/// <param name="r">The red component value of this <see cref="Color"/>.</param>
/// <param name="g">The green component value of this <see cref="Color"/>.</param>
/// <param name="b">The blue component value of this <see cref="Color"/>.</param>
public Color(double r, double g, double b)
: this(1.0, r, g, b)
{ }
/// <summary>
/// Initializes a new instance of the <see cref="Color"/> struct using ARGB-percent values.
/// </summary>
/// <param name="a">The alpha component value of this <see cref="Color"/>.</param>
/// <param name="r">The red component value of this <see cref="Color"/>.</param>
/// <param name="g">The green component value of this <see cref="Color"/>.</param>
/// <param name="b">The blue component value of this <see cref="Color"/>.</param>
public Color(double a, byte r, byte g, byte b)
: this(a, r.GetPercentageFromByteValue(), g.GetPercentageFromByteValue(), b.GetPercentageFromByteValue())
{ }
/// <summary>
/// Initializes a new instance of the <see cref="Color"/> struct using ARGB-percent values.
/// </summary>
/// <param name="a">The alpha component value of this <see cref="Color"/>.</param>
/// <param name="r">The red component value of this <see cref="Color"/>.</param>
/// <param name="g">The green component value of this <see cref="Color"/>.</param>
/// <param name="b">The blue component value of this <see cref="Color"/>.</param>
public Color(double a, int r, int g, int b)
: this(a, (byte)r.Clamp(0, byte.MaxValue), (byte)g.Clamp(0, byte.MaxValue), (byte)b.Clamp(0, byte.MaxValue))
{ }
/// <summary>
/// Initializes a new instance of the <see cref="Color"/> struct using ARGB-percent values.
/// </summary>
/// <param name="a">The alpha component value of this <see cref="Color"/>.</param>
/// <param name="r">The red component value of this <see cref="Color"/>.</param>
/// <param name="g">The green component value of this <see cref="Color"/>.</param>
/// <param name="b">The blue component value of this <see cref="Color"/>.</param>
public Color(int a, double r, double g, double b)
: this((byte)a.Clamp(0, byte.MaxValue), r, g, b)
{ }
/// <summary>
/// Initializes a new instance of the <see cref="Color"/> struct using ARGB-percent values.
/// </summary>
/// <param name="a">The alpha component value of this <see cref="Color"/>.</param>
/// <param name="r">The red component value of this <see cref="Color"/>.</param>
/// <param name="g">The green component value of this <see cref="Color"/>.</param>
/// <param name="b">The blue component value of this <see cref="Color"/>.</param>
public Color(byte a, double r, double g, double b)
: this(a.GetPercentageFromByteValue(), r, g, b)
{ }
/// <summary>
/// Initializes a new instance of the <see cref="Color"/> struct using ARGB-percent values.
/// </summary>
/// <param name="a">The alpha component value of this <see cref="Color"/>.</param>
/// <param name="r">The red component value of this <see cref="Color"/>.</param>
/// <param name="g">The green component value of this <see cref="Color"/>.</param>
/// <param name="b">The blue component value of this <see cref="Color"/>.</param>
public Color(double a, double r, double g, double b)
{
A = a.Clamp(0, 1);
R = r.Clamp(0, 1);
G = g.Clamp(0, 1);
B = b.Clamp(0, 1);
}
/// <inheritdoc />
/// <summary>
/// Initializes a new instance of the <see cref="T:RGB.NET.Core.Color" /> struct by cloning a existing <see cref="T:RGB.NET.Core.Color" />.
/// </summary>
/// <param name="color">The <see cref="T:RGB.NET.Core.Color" /> the values are copied from.</param>
public Color(Color color)
: this(color.A, color.R, color.G, color.B)
{ }
#endregion
#region Methods
/// <summary>
/// Gets a human-readable string, as defined by the current <see cref="Behavior"/>.
/// </summary>
/// <returns>A string that contains the individual byte values of this <see cref="Color"/>. Default format: "[A: 255, R: 255, G: 0, B: 0]".</returns>
public override string ToString() => Behavior.ToString(this);
/// <summary>
/// Tests whether the specified object is a <see cref="Color" /> and is equivalent to this <see cref="Color" />, as defined by the current <see cref="Behavior"/>.
/// </summary>
/// <param name="obj">The object to test.</param>
/// <returns><c>true</c> if <paramref name="obj" /> is a <see cref="Color" /> equivalent to this <see cref="Color" />; otherwise, <c>false</c>.</returns>
public override bool Equals(object obj) => Behavior.Equals(this, obj);
/// <summary>
/// Returns a hash code for this <see cref="Color" />, as defined by the current <see cref="Behavior"/>.
/// </summary>
/// <returns>An integer value that specifies the hash code for this <see cref="Color" />.</returns>
public override int GetHashCode() => Behavior.GetHashCode(this);
/// <summary>
/// Blends a <see cref="Color"/> over this color, as defined by the current <see cref="Behavior"/>.
/// </summary>
/// <param name="color">The <see cref="Color"/> to blend.</param>
public Color Blend(Color color) => Behavior.Blend(this, color);
#endregion
#region Operators
/// <summary>
/// Blends the provided colors as if <see cref="Blend"/> would've been called on <paramref name="color1" />.
/// </summary>
/// <param name="color1">The base color.</param>
/// <param name="color2">The color to blend.</param>
/// <returns>The blended color.</returns>
public static Color operator +(Color color1, Color color2) => color1.Blend(color2);
/// <summary>
/// Returns a value that indicates whether two specified <see cref="Color" /> are equal.
/// </summary>
/// <param name="color1">The first <see cref="Color" /> to compare.</param>
/// <param name="color2">The second <see cref="Color" /> to compare.</param>
/// <returns><c>true</c> if <paramref name="color1" /> and <paramref name="color2" /> are equal; otherwise, <c>false</c>.</returns>
public static bool operator ==(Color color1, Color color2) => color1.Equals(color2);
/// <summary>
/// Returns a value that indicates whether two specified <see cref="Color" /> are equal.
/// </summary>
/// <param name="color1">The first <see cref="Color" /> to compare.</param>
/// <param name="color2">The second <see cref="Color" /> to compare.</param>
/// <returns><c>true</c> if <paramref name="color1" /> and <paramref name="color2" /> are not equal; otherwise, <c>false</c>.</returns>
public static bool operator !=(Color color1, Color color2) => !(color1 == color2);
/// <summary>
/// Converts a <see cref="ValueTuple"/> of ARGB-components to a <see cref="Color"/>.
/// </summary>
/// <param name="components">The <see cref="ValueTuple"/> containing the components.</param>
/// <returns>The color.</returns>
public static implicit operator Color((byte r, byte g, byte b) components) => new Color(components.r, components.g, components.b);
/// <summary>
/// Converts a <see cref="ValueTuple"/> of ARGB-components to a <see cref="Color"/>.
/// </summary>
/// <param name="components">The <see cref="ValueTuple"/> containing the components.</param>
/// <returns>The color.</returns>
public static implicit operator Color((byte a, byte r, byte g, byte b) components) => new Color(components.a, components.r, components.g, components.b);
/// <summary>
/// Converts a <see cref="ValueTuple"/> of ARGB-components to a <see cref="Color"/>.
/// </summary>
/// <param name="components">The <see cref="ValueTuple"/> containing the components.</param>
/// <returns>The color.</returns>
public static implicit operator Color((int r, int g, int b) components) => new Color(components.r, components.g, components.b);
/// <summary>
/// Converts a <see cref="ValueTuple"/> of ARGB-components to a <see cref="Color"/>.
/// </summary>
/// <param name="components">The <see cref="ValueTuple"/> containing the components.</param>
/// <returns>The color.</returns>
public static implicit operator Color((int a, int r, int g, int b) components) => new Color(components.a, components.r, components.g, components.b);
/// <summary>
/// Converts a <see cref="ValueTuple"/> of ARGB-components to a <see cref="Color"/>.
/// </summary>
/// <param name="components">The <see cref="ValueTuple"/> containing the components.</param>
/// <returns>The color.</returns>
public static implicit operator Color((double r, double g, double b) components) => new Color(components.r, components.g, components.b);
/// <summary>
/// Converts a <see cref="ValueTuple"/> of ARGB-components to a <see cref="Color"/>.
/// </summary>
/// <param name="components">The <see cref="ValueTuple"/> containing the components.</param>
/// <returns>The color.</returns>
public static implicit operator Color((double a, double r, double g, double b) components) => new Color(components.a, components.r, components.g, components.b);
#endregion
}
}

227
RGB.NET.Core/Color/HSVColor.cs Normal file
View File

@ -0,0 +1,227 @@
// ReSharper disable MemberCanBePrivate.Global
// ReSharper disable UnusedMember.Global
using System;
namespace RGB.NET.Core
{
public static class HSVColor
{
#region Getter
/// <summary>
/// Gets the hue component value (HSV-color space) of this <see cref="Color"/> as degree in the range [0..360].
/// </summary>
/// <param name="color"></param>
/// <returns></returns>
public static double GetHue(this Color color) => color.GetHSV().hue;
/// <summary>
/// Gets the saturation component value (HSV-color space) of this <see cref="Color"/> in the range [0..1].
/// </summary>
/// <param name="color"></param>
/// <returns></returns>
public static double GetSaturation(this Color color) => color.GetHSV().saturation;
/// <summary>
/// Gets the value component value (HSV-color space) of this <see cref="Color"/> in the range [0..1].
/// </summary>
/// <param name="color"></param>
/// <returns></returns>
public static double GetValue(this Color color) => color.GetHSV().value;
/// <summary>
/// Gets the hue, saturation and value component values (HSV-color space) of this <see cref="Color"/>.
/// Hue as degree in the range [0..1].
/// Saturation in the range [0..1].
/// Value in the range [0..1].
/// </summary>
/// <param name="color"></param>
/// <returns></returns>
public static (double hue, double saturation, double value) GetHSV(this Color color)
=> CaclulateHSVFromRGB(color.R, color.G, color.B);
#endregion
#region Manipulation
/// <summary>
/// Adds the given HSV values to this color.
/// </summary>
/// <param name="hue">The hue value to add.</param>
/// <param name="saturation">The saturation value to add.</param>
/// <param name="value">The value value to add.</param>
/// <returns>The new color after the modification.</returns>
public static Color AddHSV(this Color color, double hue = 0, double saturation = 0, double value = 0)
{
(double cHue, double cSaturation, double cValue) = color.GetHSV();
return Create(color.A, cHue + hue, cSaturation + saturation, cValue + value);
}
/// <summary>
/// Subtracts the given HSV values to this color.
/// </summary>
/// <param name="hue">The hue value to subtract.</param>
/// <param name="saturation">The saturation value to subtract.</param>
/// <param name="value">The value value to subtract.</param>
/// <returns>The new color after the modification.</returns>
public static Color SubtractHSV(this Color color, double hue = 0, double saturation = 0, double value = 0)
{
(double cHue, double cSaturation, double cValue) = color.GetHSV();
return Create(color.A, cHue - hue, cSaturation - saturation, cValue - value);
}
/// <summary>
/// Multiplies the given HSV values to this color.
/// </summary>
/// <param name="hue">The hue value to multiply.</param>
/// <param name="saturation">The saturation value to multiply.</param>
/// <param name="value">The value value to multiply.</param>
/// <returns>The new color after the modification.</returns>
public static Color MultiplyHSV(this Color color, double hue = 1, double saturation = 1, double value = 1)
{
(double cHue, double cSaturation, double cValue) = color.GetHSV();
return Create(color.A, cHue * hue, cSaturation * saturation, cValue * value);
}
/// <summary>
/// Divides the given HSV values to this color.
/// </summary>
/// <param name="hue">The hue value to divide.</param>
/// <param name="saturation">The saturation value to divide.</param>
/// <param name="value">The value value to divide.</param>
/// <returns>The new color after the modification.</returns>
public static Color DivideHSV(this Color color, double hue = 1, double saturation = 1, double value = 1)
{
(double cHue, double cSaturation, double cValue) = color.GetHSV();
return Create(color.A, cHue / hue, cSaturation / saturation, cValue / value);
}
/// <summary>
/// Sets the given hue value of this color.
/// </summary>
/// <param name="hue">The hue value to set.</param>
/// <param name="saturation">The saturation value to set.</param>
/// <param name="value">The value value to set.</param>
/// <returns>The new color after the modification.</returns>
public static Color SetHSV(this Color color, double? hue = null, double? saturation = null, double? value = null)
{
(double cHue, double cSaturation, double cValue) = color.GetHSV();
return Create(color.A, hue ?? cHue, saturation ?? cSaturation, value ?? cValue);
}
#endregion
#region Factory
/// <summary>
/// Creates a new instance of the <see cref="T:RGB.NET.Core.Color" /> struct using HSV-Values.
/// </summary>
/// <param name="hue">The hue component value of this <see cref="Color"/>.</param>
/// <param name="saturation">The saturation component value of this <see cref="Color"/>.</param>
/// <param name="value">The value component value of this <see cref="Color"/>.</param>
/// <returns>The color created from the values.</returns>
public static Color Create(double hue, double saturation, double value)
=> Create(1.0, hue, saturation, value);
/// <summary>
/// Creates a new instance of the <see cref="T:RGB.NET.Core.Color" /> struct using AHSV-Values.
/// </summary>
/// <param name="a">The alpha component value of this <see cref="Color"/>.</param>
/// <param name="hue">The hue component value of this <see cref="Color"/>.</param>
/// <param name="saturation">The saturation component value of this <see cref="Color"/>.</param>
/// <param name="value">The value component value of this <see cref="Color"/>.</param>
/// <returns>The color created from the values.</returns>
public static Color Create(byte a, double hue, double saturation, double value)
=> Create((double)a / byte.MaxValue, hue, saturation, value);
/// <summary>
/// Creates a new instance of the <see cref="T:RGB.NET.Core.Color" /> struct using AHSV-Values.
/// </summary>
/// <param name="a">The alpha component value of this <see cref="Color"/>.</param>
/// <param name="hue">The hue component value of this <see cref="Color"/>.</param>
/// <param name="saturation">The saturation component value of this <see cref="Color"/>.</param>
/// <param name="value">The value component value of this <see cref="Color"/>.</param>
/// <returns>The color created from the values.</returns>
public static Color Create(int a, double hue, double saturation, double value)
=> Create((double)a / byte.MaxValue, hue, saturation, value);
/// <summary>
/// Creates a new instance of the <see cref="T:RGB.NET.Core.Color" /> struct using AHSV-Values.
/// </summary>
/// <param name="a">The alpha component value of this <see cref="Color"/>.</param>
/// <param name="hue">The hue component value of this <see cref="Color"/>.</param>
/// <param name="saturation">The saturation component value of this <see cref="Color"/>.</param>
/// <param name="value">The value component value of this <see cref="Color"/>.</param>
/// <returns>The color created from the values.</returns>
public static Color Create(double a, double hue, double saturation, double value)
{
(double r, double g, double b) = CalculateRGBFromHSV(hue, saturation, value);
return new Color(a, r, g, b);
}
#endregion
#region Helper
private static (double h, double s, double v) CaclulateHSVFromRGB(double r, double g, double b)
{
if (r.EqualsInTolerance(g) && g.EqualsInTolerance(b)) return (0, 0, r);
double min = Math.Min(Math.Min(r, g), b);
double max = Math.Max(Math.Max(r, g), b);
double hue;
if (max.EqualsInTolerance(min))
hue = 0;
else if (max.EqualsInTolerance(r)) // r is max
hue = (g - b) / (max - min);
else if (max.EqualsInTolerance(g)) // g is max
hue = 2.0 + ((b - r) / (max - min));
else // b is max
hue = 4.0 + ((r - g) / (max - min));
hue = hue * 60.0;
hue = hue.Wrap(0, 360);
double saturation = max.EqualsInTolerance(0) ? 0 : 1.0 - (min / max);
double value = Math.Max(r, Math.Max(g, b));
return (hue, saturation, value);
}
private static (double r, double g, double b) CalculateRGBFromHSV(double h, double s, double v)
{
h = h.Wrap(0, 360);
s = s.Clamp(0, 1);
v = v.Clamp(0, 1);
if (s <= 0.0)
return (v, v, v);
double hh = h / 60.0;
int i = (int)hh;
double ff = hh - i;
double p = v * (1.0 - s);
double q = v * (1.0 - (s * ff));
double t = v * (1.0 - (s * (1.0 - ff)));
switch (i)
{
case 0:
return (v, t, p);
case 1:
return (q, v, p);
case 2:
return (p, v, t);
case 3:
return (p, q, v);
case 4:
return (t, p, v);
default:
return (v, p, q);
}
}
#endregion
}
}

275
RGB.NET.Core/Color/RGBColor.cs Normal file
View File

@ -0,0 +1,275 @@
// ReSharper disable MemberCanBePrivate.Global
// ReSharper disable UnusedMember.Global
using System;
namespace RGB.NET.Core
{
public static class RGBColor
{
#region Getter
/// <summary>
/// Gets the A component value of this <see cref="Color"/> as byte in the range [0..255].
/// </summary>
/// <param name="color"></param>
/// <returns></returns>
public static byte GetA(this Color color) => color.A.GetByteValueFromPercentage();
/// <summary>
/// Gets the R component value of this <see cref="Color"/> as byte in the range [0..255].
/// </summary>
/// <param name="color"></param>
/// <returns></returns>
public static byte GetR(this Color color) => color.R.GetByteValueFromPercentage();
/// <summary>
/// Gets the G component value of this <see cref="Color"/> as byte in the range [0..255].
/// </summary>
/// <param name="color"></param>
/// <returns></returns>
public static byte GetG(this Color color) => color.G.GetByteValueFromPercentage();
/// <summary>
/// Gets the B component value of this <see cref="Color"/> as byte in the range [0..255].
/// </summary>
/// <param name="color"></param>
/// <returns></returns>
public static byte GetB(this Color color) => color.B.GetByteValueFromPercentage();
/// <summary>
/// Gets the A, R, G and B component value of this <see cref="Color"/> as byte in the range [0..255].
/// </summary>
/// <param name="color"></param>
/// <returns></returns>
public static (byte a, byte r, byte g, byte b) GetRGBBytes(this Color color)
=> (color.GetA(), color.GetR(), color.GetG(), color.GetB());
/// <summary>
/// Gets the A, R, G and B component value of this <see cref="Color"/> as percentage in the range [0..1].
/// </summary>
/// <param name="color"></param>
/// <returns></returns>
public static (double a, double r, double g, double b) GetRGB(this Color color)
=> (color.A, color.R, color.G, color.B);
#endregion
#region Manipulation
#region Add
/// <summary>
/// Adds the given RGB values to this color.
/// </summary>
/// <param name="r">The red value to add.</param>
/// <param name="g">The green value to add.</param>
/// <param name="b">The blue value to add.</param>
/// <returns>The new color after the modification.</returns>
public static Color AddRGB(this Color color, int r = 0, int g = 0, int b = 0)
=> new Color(color.A, color.GetR() + r, color.GetG() + g, color.GetB() + b);
/// <summary>
/// Adds the given RGB-percent values to this color.
/// </summary>
/// <param name="r">The red value to add.</param>
/// <param name="g">The green value to add.</param>
/// <param name="b">The blue value to add.</param>
/// <returns>The new color after the modification.</returns>
public static Color AddRGB(this Color color, double r = 0, double g = 0, double b = 0)
=> new Color(color.A, color.R + r, color.G + g, color.B + b);
/// <summary>
/// Adds the given alpha value to this color.
/// </summary>
/// <param name="a">The alpha value to add.</param>
/// <returns>The new color after the modification.</returns>
public static Color AddA(this Color color, int a)
=> new Color(color.GetA() + a, color.R, color.G, color.B);
/// <summary>
/// Adds the given alpha-percent value to this color.
/// </summary>
/// <param name="a">The alpha value to add.</param>
/// <returns>The new color after the modification.</returns>
public static Color AddA(this Color color, double a)
=> new Color(color.A + a, color.R, color.G, color.B);
#endregion
#region Subtract
/// <summary>
/// Subtracts the given RGB values to this color.
/// </summary>
/// <param name="r">The red value to subtract.</param>
/// <param name="g">The green value to subtract.</param>
/// <param name="b">The blue value to subtract.</param>
/// <returns>The new color after the modification.</returns>
public static Color SubtractRGB(this Color color, int r = 0, int g = 0, int b = 0)
=> new Color(color.A, color.GetR() - r, color.GetG() - g, color.GetB() - b);
/// <summary>
/// Subtracts the given RGB values to this color.
/// </summary>
/// <param name="r">The red value to subtract.</param>
/// <param name="g">The green value to subtract.</param>
/// <param name="b">The blue value to subtract.</param>
/// <returns>The new color after the modification.</returns>
public static Color SubtractRGB(this Color color, double r = 0, double g = 0, double b = 0)
=> new Color(color.A, color.R - r, color.G - g, color.B - b);
/// <summary>
/// Subtracts the given alpha value to this color.
/// </summary>
/// <param name="a">The alpha value to subtract.</param>
/// <returns>The new color after the modification.</returns>
public static Color SubtractA(this Color color, int a)
=> new Color(color.GetA() - a, color.R, color.G, color.B);
/// <summary>
/// Subtracts the given alpha-percent value to this color.
/// </summary>
/// <param name="a">The alpha value to subtract.</param>
/// <returns>The new color after the modification.</returns>
public static Color SubtractA(this Color color, double aPercent)
=> new Color(color.A - aPercent, color.R, color.G, color.B);
#endregion
#region Multiply
/// <summary>
/// Multiplies the given RGB values to this color.
/// </summary>
/// <param name="r">The red value to multiply.</param>
/// <param name="g">The green value to multiply.</param>
/// <param name="b">The blue value to multiply.</param>
/// <returns>The new color after the modification.</returns>
public static Color MultiplyRGB(this Color color, double r = 1, double g = 1, double b = 1)
=> new Color(color.A, color.R * r, color.G * g, color.B * b);
/// <summary>
/// Multiplies the given alpha value to this color.
/// </summary>
/// <param name="a">The alpha value to multiply.</param>
/// <returns>The new color after the modification.</returns>
public static Color MultiplyA(this Color color, double a)
=> new Color(color.A * a, color.R, color.G, color.B);
#endregion
#region Divide
/// <summary>
/// Divides the given RGB values to this color.
/// </summary>
/// <param name="r">The red value to divide.</param>
/// <param name="g">The green value to divide.</param>
/// <param name="b">The blue value to divide.</param>
/// <returns>The new color after the modification.</returns>
public static Color DivideRGB(this Color color, double r = 1, double g = 1, double b = 1)
=> new Color(color.A, color.R / r, color.G / g, color.B / b);
/// <summary>
/// Divides the given alpha value to this color.
/// </summary>
/// <param name="a">The alpha value to divide.</param>
/// <returns>The new color after the modification.</returns>
public static Color DivideA(this Color color, double a)
=> new Color(color.A / a, color.R, color.G, color.B);
#endregion
#region Set
/// <summary>
/// Sets the given RGB value of this color.
/// </summary>
/// <param name="r">The red value to set.</param>
/// <param name="g">The green value to set.</param>
/// <param name="b">The blue value to set.</param>
/// <returns>The new color after the modification.</returns>
public static Color SetRGB(this Color color, byte? r = null, byte? g = null, byte? b = null)
=> new Color(color.A, r ?? color.GetR(), g ?? color.GetG(), b ?? color.GetB());
/// <summary>
/// Sets the given RGB value of this color.
/// </summary>
/// <param name="r">The red value to set.</param>
/// <param name="g">The green value to set.</param>
/// <param name="b">The blue value to set.</param>
/// <returns>The new color after the modification.</returns>
public static Color SetRGB(this Color color, int? r = null, int? g = null, int? b = null)
=> new Color(color.A, r ?? color.GetR(), g ?? color.GetG(), b ?? color.GetB());
/// <summary>
/// Sets the given RGB value of this color.
/// </summary>
/// <param name="r">The red value to set.</param>
/// <param name="g">The green value to set.</param>
/// <param name="b">The blue value to set.</param>
/// <returns>The new color after the modification.</returns>
public static Color SetRGB(this Color color, double? r = null, double? g = null, double? b = null)
=> new Color(color.A, r ?? color.R, g ?? color.G, b ?? color.B);
/// <summary>
/// Sets the given alpha value of this color.
/// </summary>
/// <param name="a">The alpha value to set.</param>
/// <returns>The new color after the modification.</returns>
public static Color SetA(this Color color, int a) => new Color(a, color.R, color.G, color.B);
/// <summary>
/// Sets the given alpha value of this color.
/// </summary>
/// <param name="a">The alpha value to set.</param>
/// <returns>The new color after the modification.</returns>
public static Color SetA(this Color color, double a) => new Color(a, color.R, color.G, color.B);
#endregion
#endregion
#region Conversion
/// <summary>
/// Gets the current color as a RGB-HEX-string.
/// </summary>
/// <returns>The RGB-HEX-string.</returns>
public static string AsRGBHexString(this Color color, bool leadingHash = true) => (leadingHash ? "#" : "") + ConversionHelper.ToHex(color.GetR(), color.GetG(), color.GetB());
/// <summary>
/// Gets the current color as a ARGB-HEX-string.
/// </summary>
/// <returns>The ARGB-HEX-string.</returns>
public static string AsARGBHexString(this Color color, bool leadingHash = true) => (leadingHash ? "#" : "") + ConversionHelper.ToHex(color.GetA(), color.GetR(), color.GetG(), color.GetB());
#endregion
#region Factory
/// <summary>
/// Creates a new instance of the <see cref="T:RGB.NET.Core.Color" /> struct using a HEX-string.
/// </summary>
/// <param name="hexString">The HEX-representation of the color.</param>
/// <returns>The color created from the HEX-string.</returns>
public static Color FromHexString(string hexString)
{
if ((hexString == null) || (hexString.Length < 6))
throw new ArgumentException("Invalid hex string", nameof(hexString));
if (hexString[0] == '#')
hexString = hexString.Substring(1);
byte[] data = ConversionHelper.HexToBytes(hexString);
if (data.Length == 3)
return new Color(data[0], data[1], data[2]);
if (data.Length == 4)
return new Color(data[0], data[1], data[2], data[3]);
throw new ArgumentException("Invalid hex string", nameof(hexString));
}
#endregion
}
}

28
RGB.NET.Core/Extensions/MathExtensions.cs
View File

@ -36,7 +36,14 @@ namespace RGB.NET.Core
/// <param name="max">The higher value of the range the value is clamped to.</param>
/// <returns>The clamped value.</returns>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double Clamp(this double value, double min, double max) => Math.Max(min, Math.Min(max, value));
public static double Clamp(this double value, double min, double max)
{
// ReSharper disable ConvertIfStatementToReturnStatement - I'm not sure why, but inlining this statement reduces performance by ~10%
if (value < min) return min;
if (value > max) return max;
return value;
// ReSharper restore ConvertIfStatementToReturnStatement
}
/// <summary>
/// Clamps the provided value to be bigger or equal min and smaller or equal max.
@ -46,7 +53,14 @@ namespace RGB.NET.Core
/// <param name="max">The higher value of the range the value is clamped to.</param>
/// <returns>The clamped value.</returns>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static int Clamp(this int value, int min, int max) => Math.Max(min, Math.Min(max, value));
public static int Clamp(this int value, int min, int max)
{
// ReSharper disable ConvertIfStatementToReturnStatement - I'm not sure why, but inlining this statement reduces performance by ~10%
if (value < min) return min;
if (value > max) return max;
return value;
// ReSharper restore ConvertIfStatementToReturnStatement
}
/// <summary>
/// Enforces the provided value to be in the specified range by wrapping it around the edges if it exceeds them.
@ -68,16 +82,20 @@ namespace RGB.NET.Core
return value;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static byte GetByteValueFromPercentage(this double percentage)
{
if (double.IsNaN(percentage)) return 0;
percentage = percentage.Clamp(0, 1.0);
return (byte)(percentage.Equals(1.0) ? 255 : percentage * 256.0);
return (byte)(percentage >= 1.0 ? 255 : percentage * 256.0);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double GetPercentageFromByteValue(this byte value)
=> ((double)value) / byte.MaxValue;
#endregion
}
}

1124
RGB.NET.Core/Leds/Color.cs
View File

File diff suppressed because it is too large Load Diff

2
RGB.NET.Core/RGB.NET.Core.csproj.DotSettings
View File

@ -1,6 +1,8 @@
<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=brushes/@EntryIndexedValue">True</s:Boolean>
<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=color/@EntryIndexedValue">True</s:Boolean>
<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=colorcorrection/@EntryIndexedValue">True</s:Boolean>
<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=color_005Cbehaviors/@EntryIndexedValue">True</s:Boolean>
<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=decorators/@EntryIndexedValue">True</s:Boolean>
<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=devices/@EntryIndexedValue">True</s:Boolean>
<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=devices_005Cupdate/@EntryIndexedValue">True</s:Boolean>

2
RGB.NET.Decorators/Brush/FlashDecorator.cs
View File

@ -77,7 +77,7 @@ namespace RGB.NET.Decorators.Brush
#region Methods
/// <inheritdoc />
public Color ManipulateColor(Rectangle rectangle, BrushRenderTarget renderTarget, Color color) => color.SetAPercent(_currentValue);
public Color ManipulateColor(Rectangle rectangle, BrushRenderTarget renderTarget, Color color) => color.SetA(_currentValue);
/// <inheritdoc />
protected override void Update(double deltaTime)

6
RGB.NET.Devices.Asus/Generic/AsusUpdateQueue.cs
View File

@ -57,9 +57,9 @@ namespace RGB.NET.Devices.Asus
foreach (KeyValuePair<object, Color> data in dataSet)
{
int index = ((int)data.Key) * 3;
ColorData[index] = data.Value.R;
ColorData[index + 1] = data.Value.B;
ColorData[index + 2] = data.Value.G;
ColorData[index] = data.Value.GetR();
ColorData[index + 1] = data.Value.GetB();
ColorData[index + 2] = data.Value.GetG();
}
_updateAction(_handle, ColorData);

2
RGB.NET.Devices.CoolerMaster/Generic/CoolerMasterUpdateQueue.cs
View File

@ -39,7 +39,7 @@ namespace RGB.NET.Devices.CoolerMaster
foreach (KeyValuePair<object, Color> data in dataSet)
{
(int row, int column) = ((int, int))data.Key;
_CoolerMasterSDK.SetLedColor(row, column, data.Value.R, data.Value.G, data.Value.B, _deviceIndex);
_CoolerMasterSDK.SetLedColor(row, column, data.Value.GetR(), data.Value.GetG(), data.Value.GetB(), _deviceIndex);
}
_CoolerMasterSDK.RefreshLed(false, _deviceIndex);

20
RGB.NET.Devices.Corsair/CorsairDeviceProvider.cs
View File

@ -215,7 +215,8 @@ namespace RGB.NET.Devices.Corsair
for (int channel = 0; channel < channelsInfo.channelsCount; channel++)
{
CorsairLedId referenceLed = channel == 0 ? CorsairLedId.CustomDeviceChannel1Led1 : CorsairLedId.CustomDeviceChannel2Led1;
CorsairLedId referenceLed = GetChannelReferenceId(info.CorsairDeviceType, channel);
if (referenceLed == CorsairLedId.Invalid) continue;
_CorsairChannelInfo channelInfo = (_CorsairChannelInfo)Marshal.PtrToStructure(channelInfoPtr, typeof(_CorsairChannelInfo));
@ -247,6 +248,23 @@ namespace RGB.NET.Devices.Corsair
}
}
private static CorsairLedId GetChannelReferenceId(CorsairDeviceType deviceType, int channel)
{
if (deviceType == CorsairDeviceType.Cooler)
return CorsairLedId.CustomLiquidCoolerChannel1Led1;
else
{
switch (channel)
{
case 0: return CorsairLedId.CustomDeviceChannel1Led1;
case 1: return CorsairLedId.CustomDeviceChannel2Led1;
case 2: return CorsairLedId.CustomDeviceChannel3Led1;
}
}
return CorsairLedId.Invalid;
}
private void AddSpecialParts(ICorsairRGBDevice device)
{
if (device.DeviceInfo.Model.Equals("K95 RGB Platinum", StringComparison.OrdinalIgnoreCase))

6
RGB.NET.Devices.Corsair/Generic/CorsairDeviceUpdateQueue.cs
View File

@ -46,9 +46,9 @@ namespace RGB.NET.Devices.Corsair
_CorsairLedColor color = new _CorsairLedColor
{
ledId = (int)data.Key,
r = data.Value.R,
g = data.Value.G,
b = data.Value.B
r = data.Value.GetR(),
g = data.Value.GetG(),
b = data.Value.GetB()
};
Marshal.StructureToPtr(color, addPtr, false);

6
RGB.NET.Devices.Logitech/PerDevice/LogitechPerDeviceUpdateQueue.cs
View File

@ -32,9 +32,9 @@ namespace RGB.NET.Devices.Logitech
Color color = dataSet.Values.First();
_LogitechGSDK.LogiLedSetTargetDevice(LogitechDeviceCaps.DeviceRGB);
_LogitechGSDK.LogiLedSetLighting((int)Math.Round(color.RPercent * 100),
(int)Math.Round(color.GPercent * 100),
(int)Math.Round(color.BPercent * 100));
_LogitechGSDK.LogiLedSetLighting((int)Math.Round(color.R * 100),
(int)Math.Round(color.G * 100),
(int)Math.Round(color.B * 100));
}
#endregion

8
RGB.NET.Devices.Logitech/PerKey/BitmapMapping.cs
View File

@ -158,10 +158,10 @@ namespace RGB.NET.Devices.Logitech
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void SetColor(byte[] bitmap, int offset, Color color)
{
bitmap[offset] = color.B;
bitmap[offset + 1] = color.G;
bitmap[offset + 2] = color.R;
bitmap[offset + 3] = color.A;
bitmap[offset] = color.GetB();
bitmap[offset + 1] = color.GetG();
bitmap[offset + 2] = color.GetR();
bitmap[offset + 3] = color.GetA();
}
#endregion

6
RGB.NET.Devices.Logitech/PerKey/LogitechPerKeyUpdateQueue.cs
View File

@ -51,9 +51,9 @@ namespace RGB.NET.Devices.Logitech
}
else
_LogitechGSDK.LogiLedSetLightingForKeyWithKeyName((int)customData,
(int)Math.Round(data.Value.RPercent * 100),
(int)Math.Round(data.Value.GPercent * 100),
(int)Math.Round(data.Value.BPercent * 100));
(int)Math.Round(data.Value.R * 100),
(int)Math.Round(data.Value.G * 100),
(int)Math.Round(data.Value.B * 100));
}
if (usesBitmap)

6
RGB.NET.Devices.Logitech/Zone/LogitechZoneUpdateQueue.cs
View File

@ -56,9 +56,9 @@ namespace RGB.NET.Devices.Logitech
{
int zone = (int)data.Key;
_LogitechGSDK.LogiLedSetLightingForTargetZone(_deviceType, zone,
(int)Math.Round(data.Value.RPercent * 100),
(int)Math.Round(data.Value.GPercent * 100),
(int)Math.Round(data.Value.BPercent * 100));
(int)Math.Round(data.Value.R * 100),
(int)Math.Round(data.Value.G * 100),
(int)Math.Round(data.Value.B * 100));
}
}

2
RGB.NET.Devices.Msi/Generic/MsiRGBDevice.cs
View File

@ -66,7 +66,7 @@ namespace RGB.NET.Devices.Msi
{
string deviceType = DeviceInfo.MsiDeviceType;
foreach (Led led in leds)
_MsiSDK.SetLedColor(deviceType, (int)led.CustomData, led.Color.R, led.Color.G, led.Color.B);
_MsiSDK.SetLedColor(deviceType, (int)led.CustomData, led.Color.GetR(), led.Color.GetG(), led.Color.GetB());
}
}

14
RGB.NET.Devices.Novation/Generic/LimitedColorUpdateQueue.cs
View File

@ -40,14 +40,16 @@ namespace RGB.NET.Devices.Novation
/// <returns>The novation-representation of the <see cref="Color"/>.</returns>
protected virtual int ConvertColor(Color color)
{
if ((color.Hue >= 330) || (color.Hue < 30))
return (int)Math.Ceiling(color.Value * 3); // red with brightness 1, 2 or 3
(double hue, double saturation, double value) = color.GetHSV();
if ((color.Hue >= 30) && (color.Hue < 90)) // yellow with brightness 17, 34 or 51
return (int)Math.Ceiling(color.Value * 3) * 17;
if ((hue >= 330) || (hue < 30))
return (int)Math.Ceiling(value * 3); // red with brightness 1, 2 or 3
if ((color.Hue >= 90) && (color.Hue < 150)) // green with brightness 16, 32 or 48
return (int)Math.Ceiling(color.Value * 3) * 16;
if ((hue >= 30) && (hue < 90)) // yellow with brightness 17, 34 or 51
return (int)Math.Ceiling(value * 3) * 17;
if ((hue >= 90) && (hue < 150)) // green with brightness 16, 32 or 48
return (int)Math.Ceiling(value * 3) * 16;
return 0;
}

2
RGB.NET.Devices.Razer/Native/_Color.cs
View File

@ -21,7 +21,7 @@ namespace RGB.NET.Devices.Razer.Native
#region Constructors
public _Color(Color color)
: this(color.R, color.G, color.B) { }
: this(color.GetR(), color.GetG(), color.GetB()) { }
public _Color(byte red, byte green, byte blue)
: this()

2
RGB.NET.Devices.SoIP/Client/SoIPClientRGBDevice.cs
View File

@ -66,7 +66,7 @@ namespace RGB.NET.Devices.SoIP.Client
List<(LedId, Color)> leds = message.MessageString.Split(';').Select(x =>
{
string[] led = x.Split('|');
return ((LedId)Enum.Parse(typeof(LedId), led[0]), Color.FromHexString(led[1]));
return ((LedId)Enum.Parse(typeof(LedId), led[0]), RGBColor.FromHexString(led[1]));
}).ToList();
lock (_syncbackCache)
foreach ((LedId ledId, Color color) in leds)

2
RGB.NET.Devices.SoIP/Server/SoIPServerRGBDevice.cs
View File

@ -61,7 +61,7 @@ namespace RGB.NET.Devices.SoIP.Server
tcpClient.GetStream().WriteAsync(messageData, 0, messageData.Length);
}
private string GetLedString(IEnumerable<Led> leds) => string.Join(";", leds.Select(x => x.Id.ToString() + "|" + x.Color.AsARGBHexString()));
private string GetLedString(IEnumerable<Led> leds) => string.Join(";", leds.Select(x => x.Id.ToString() + "|" + x.Color.AsARGBHexString(false)));
/// <inheritdoc />
public override void Dispose()

2
RGB.NET.Devices.SoIP/Server/SoIPServerUpdateQueue.cs
View File

@ -46,7 +46,7 @@ namespace RGB.NET.Devices.SoIP.Server
}
}
private string GetLedString(Dictionary<object, Color> dataSet) => string.Join(";", dataSet.Select(x => x.Key.ToString() + "|" + x.Value.AsARGBHexString()));
private string GetLedString(Dictionary<object, Color> dataSet) => string.Join(";", dataSet.Select(x => x.Key.ToString() + "|" + x.Value.AsARGBHexString(false)));
#endregion
}

2
RGB.NET.Devices.WS281X/Arduino/ArduinoWS2812USBUpdateQueue.cs
View File

@ -62,7 +62,7 @@ namespace RGB.NET.Devices.WS281X.Arduino
dataBuffer[0] = (byte)((channel << 4) | UPDATE_COMMAND[0]);
int i = 1;
foreach ((byte _, byte r, byte g, byte b) in channelData.OrderBy(x => x.Item1.key)
.Select(x => x.Value))
.Select(x => x.Value.GetRGBBytes()))
{
dataBuffer[i++] = r;
dataBuffer[i++] = g;

2
RGB.NET.Devices.WS281X/Bitwizard/BitwizardWS2812USBUpdateQueue.cs
View File

@ -39,7 +39,7 @@ namespace RGB.NET.Devices.WS281X.Bitwizard
protected override IEnumerable<string> GetCommands(Dictionary<object, Color> dataSet)
{
foreach (KeyValuePair<object, Color> data in dataSet)
yield return $"pix {(int)data.Key} {data.Value.AsRGBHexString()}";
yield return $"pix {(int)data.Key} {data.Value.AsRGBHexString(false)}";
}
#endregion

9
RGB.NET.sln
View File

@ -41,6 +41,10 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RGB.NET.Devices.WS281X", "R
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RGB.NET.Devices.SteelSeries", "RGB.NET.Devices.SteelSeries\RGB.NET.Devices.SteelSeries.csproj", "{FFDE4387-60F2-47B6-9704-3A57D02B8C64}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Tests", "Tests", "{92D7C263-D4C9-4D26-93E2-93C1F9C2CD16}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RGB.NET.Core.Tests", "Tests\RGB.NET.Core.Tests\RGB.NET.Core.Tests.csproj", "{A3FD5AD7-040A-47CA-A278-53493A25FF8A}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
@ -115,6 +119,10 @@ Global
{FFDE4387-60F2-47B6-9704-3A57D02B8C64}.Debug|Any CPU.Build.0 = Debug|Any CPU
{FFDE4387-60F2-47B6-9704-3A57D02B8C64}.Release|Any CPU.ActiveCfg = Release|Any CPU
{FFDE4387-60F2-47B6-9704-3A57D02B8C64}.Release|Any CPU.Build.0 = Release|Any CPU
{A3FD5AD7-040A-47CA-A278-53493A25FF8A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{A3FD5AD7-040A-47CA-A278-53493A25FF8A}.Debug|Any CPU.Build.0 = Debug|Any CPU
{A3FD5AD7-040A-47CA-A278-53493A25FF8A}.Release|Any CPU.ActiveCfg = Release|Any CPU
{A3FD5AD7-040A-47CA-A278-53493A25FF8A}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
@ -136,6 +144,7 @@ Global
{6FEBDC9E-909D-4EE2-B003-EDFBEF5FFF40} = {EBC33090-8494-4DF4-B4B6-64D0E531E93F}
{0AD382DA-E999-4F74-9658-8D402EE9BF3F} = {D13032C6-432E-4F43-8A32-071133C22B16}
{FFDE4387-60F2-47B6-9704-3A57D02B8C64} = {D13032C6-432E-4F43-8A32-071133C22B16}
{A3FD5AD7-040A-47CA-A278-53493A25FF8A} = {92D7C263-D4C9-4D26-93E2-93C1F9C2CD16}
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {7F222AD4-1F9E-4AAB-9D69-D62372D4C1BA}

395
Tests/RGB.NET.Core.Tests/Color/ColorTest.cs Normal file
View File

@ -0,0 +1,395 @@
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace RGB.NET.Core.Tests.Color
{
[TestClass]
public class ColorTest
{
#region Basics
[TestMethod]
public void VerifyTransparent()
{
Core.Color transparent = Core.Color.Transparent;
Assert.AreEqual(0, transparent.GetA(), "A is not 0");
Assert.AreEqual(0, transparent.GetR(), "R is not 0");
Assert.AreEqual(0, transparent.GetG(), "G is not 0");
Assert.AreEqual(0, transparent.GetB(), "B is not 0");
}
[TestMethod]
public void ToStringTest()
{
Core.Color color = new Core.Color(255, 120, 13, 1);
Assert.AreEqual("[A: 255, R: 120, G: 13, B: 1]", color.ToString());
}
#region HashCode
[TestMethod]
public void GetHashCodeTestEqual()
{
Core.Color color1 = new Core.Color(100, 68, 32, 255);
Core.Color color2 = new Core.Color(100, 68, 32, 255);
Assert.AreEqual(color1.GetHashCode(), color2.GetHashCode());
}
[TestMethod]
public void GetHashCodeTestNotEqualA()
{
Core.Color color1 = new Core.Color(100, 68, 32, 255);
Core.Color color2 = new Core.Color(99, 68, 32, 255);
Assert.AreNotEqual(color1.GetHashCode(), color2.GetHashCode());
}
[TestMethod]
public void GetHashCodeTestNotEqualR()
{
Core.Color color1 = new Core.Color(100, 68, 32, 255);
Core.Color color2 = new Core.Color(100, 69, 32, 255);
Assert.AreNotEqual(color1.GetHashCode(), color2.GetHashCode());
}
[TestMethod]
public void GetHashCodeTestNotEqualG()
{
Core.Color color1 = new Core.Color(100, 68, 32, 255);
Core.Color color2 = new Core.Color(100, 68, 200, 255);
Assert.AreNotEqual(color1.GetHashCode(), color2.GetHashCode());
}
[TestMethod]
public void GetHashCodeTestNotEqualB()
{
Core.Color color1 = new Core.Color(100, 68, 32, 255);
Core.Color color2 = new Core.Color(100, 68, 32, 0);
Assert.AreNotEqual(color1.GetHashCode(), color2.GetHashCode());
}
#endregion
#region Equality
[TestMethod]
public void EqualityTestEqual()
{
Core.Color color1 = new Core.Color(100, 68, 32, 255);
Core.Color color2 = new Core.Color(100, 68, 32, 255);
Assert.IsTrue(color1.Equals(color2), $"Equals returns false on equal colors {color1} and {color2}");
Assert.IsTrue(color1 == color2, $"Equal-operator returns false on equal colors {color1} and {color2}");
Assert.IsFalse(color1 != color2, $"Not-Equal-operator returns true on equal colors {color1} and {color2}");
}
[TestMethod]
public void EqualityTestNotEqualA()
{
Core.Color color1 = new Core.Color(100, 68, 32, 255);
Core.Color color2 = new Core.Color(99, 68, 32, 255);
Assert.IsFalse(color1.Equals(color2), $"Equals returns true on not equal colors {color1} and {color2}");
Assert.IsFalse(color1 == color2, $"Equal-operator returns true on not equal colors {color1} and {color2}");
Assert.IsTrue(color1 != color2, $"Not-Equal-operator returns false on not equal colors {color1} and {color2}");
}
[TestMethod]
public void EqualityTestNotEqualR()
{
Core.Color color1 = new Core.Color(100, 68, 32, 255);
Core.Color color2 = new Core.Color(100, 69, 32, 255);
Assert.IsFalse(color1.Equals(color2), $"Equals returns true on not equal colors {color1} and {color2}");
Assert.IsFalse(color1 == color2, $"Equal-operator returns true on not equal colors {color1} and {color2}");
Assert.IsTrue(color1 != color2, $"Not-Equal-operator returns false on not equal colors {color1} and {color2}");
}
[TestMethod]
public void EqualityTestNotEqualG()
{
Core.Color color1 = new Core.Color(100, 68, 32, 255);
Core.Color color2 = new Core.Color(100, 68, 200, 255);
Assert.IsFalse(color1.Equals(color2), $"Equals returns true on not equal colors {color1} and {color2}");
Assert.IsFalse(color1 == color2, $"Equal-operator returns true on not equal colors {color1} and {color2}");
Assert.IsTrue(color1 != color2, $"Not-Equal-operator returns false on not equal colors {color1} and {color2}");
}
[TestMethod]
public void EqualityTestNotEqualB()
{
Core.Color color1 = new Core.Color(100, 68, 32, 255);
Core.Color color2 = new Core.Color(100, 68, 32, 0);
Assert.IsFalse(color1.Equals(color2), $"Equals returns true on not equal colors {color1} and {color2}");
Assert.IsFalse(color1 == color2, $"Equal-operator returns true on not equal colors {color1} and {color2}");
Assert.IsTrue(color1 != color2, $"Not-Equal-operator returns false on not equal colors {color1} and {color2}");
}
#endregion
#endregion
#region Constructors
[TestMethod]
public void RGBByteConstructorTest()
{
Core.Color color = new Core.Color((byte)10, (byte)120, (byte)255);
Assert.AreEqual(255, color.GetA(), "A is not 255");
Assert.AreEqual(10, color.GetR(), "R is not 10");
Assert.AreEqual(120, color.GetG(), "G is not 120");
Assert.AreEqual(255, color.GetB(), "B is not 255");
}
[TestMethod]
public void ARGBByteConstructorTest()
{
Core.Color color = new Core.Color((byte)200, (byte)10, (byte)120, (byte)255);
Assert.AreEqual(200, color.GetA(), "A is not 200");
Assert.AreEqual(10, color.GetR(), "R is not 10");
Assert.AreEqual(120, color.GetG(), "G is not 120");
Assert.AreEqual(255, color.GetB(), "B is not 255");
}
[TestMethod]
public void RGBIntConstructorTest()
{
Core.Color color = new Core.Color(10, 120, 255);
Assert.AreEqual(255, color.GetA(), "A is not 255");
Assert.AreEqual(10, color.GetR(), "R is not 10");
Assert.AreEqual(120, color.GetG(), "G is not 120");
Assert.AreEqual(255, color.GetB(), "B is not 255");
}
[TestMethod]
public void ARGBIntConstructorTest()
{
Core.Color color = new Core.Color(200, 10, 120, 255);
Assert.AreEqual(200, color.GetA(), "A is not 200");
Assert.AreEqual(10, color.GetR(), "R is not 10");
Assert.AreEqual(120, color.GetG(), "G is not 120");
Assert.AreEqual(255, color.GetB(), "B is not 255");
}
[TestMethod]
public void RGBIntConstructorClampTest()
{
Core.Color color1 = new Core.Color(256, 256, 256);
Assert.AreEqual(255, color1.GetA(), "A is not 255");
Assert.AreEqual(255, color1.GetR(), "R is not 255");
Assert.AreEqual(255, color1.GetG(), "G is not 255");
Assert.AreEqual(255, color1.GetB(), "B is not 255");
Core.Color color2 = new Core.Color(-1, -1, -1);
Assert.AreEqual(255, color2.GetA(), "A is not 255");
Assert.AreEqual(0, color2.GetR(), "R is not 0");
Assert.AreEqual(0, color2.GetG(), "G is not 0");
Assert.AreEqual(0, color2.GetB(), "B is not 0");
}
[TestMethod]
public void ARGBIntConstructorClampTest()
{
Core.Color color = new Core.Color(256, 256, 256, 256);
Assert.AreEqual(255, color.GetA(), "A is not 255");
Assert.AreEqual(255, color.GetR(), "R is not 255");
Assert.AreEqual(255, color.GetG(), "G is not 255");
Assert.AreEqual(255, color.GetB(), "B is not 255");
Core.Color color2 = new Core.Color(-1, -1, -1, -1);
Assert.AreEqual(0, color2.GetA(), "A is not 0");
Assert.AreEqual(0, color2.GetR(), "R is not 0");
Assert.AreEqual(0, color2.GetG(), "G is not 0");
Assert.AreEqual(0, color2.GetB(), "B is not 0");
}
[TestMethod]
public void RGBPercentConstructorTest()
{
Core.Color color = new Core.Color(0.25341, 0.55367, 1);
Assert.AreEqual(1, color.A, DoubleExtensions.TOLERANCE, "A is not 1");
Assert.AreEqual(0.25341, color.R, DoubleExtensions.TOLERANCE, "R is not 0.25341");
Assert.AreEqual(0.55367, color.G, DoubleExtensions.TOLERANCE, "G is not 0.55367");
Assert.AreEqual(1, color.B, DoubleExtensions.TOLERANCE, "B is not 1");
}
[TestMethod]
public void ARGBPercentConstructorTest()
{
Core.Color color = new Core.Color(0.3315, 0.25341, 0.55367, 1);
Assert.AreEqual(0.3315, color.A, DoubleExtensions.TOLERANCE, "A is not 0.3315");
Assert.AreEqual(0.25341, color.R, DoubleExtensions.TOLERANCE, "R is not 0.25341");
Assert.AreEqual(0.55367, color.G, DoubleExtensions.TOLERANCE, "G is not 0.55367");
Assert.AreEqual(1, color.B, DoubleExtensions.TOLERANCE, "B is not 1");
}
[TestMethod]
public void RGBPercentConstructorClampTest()
{
Core.Color color1 = new Core.Color(1.1, 1.1, 1.1);
Assert.AreEqual(1, color1.A, "A is not 1");
Assert.AreEqual(1, color1.R, "R is not 1");
Assert.AreEqual(1, color1.G, "G is not 1");
Assert.AreEqual(1, color1.B, "B is not 1");
Core.Color color2 = new Core.Color(-1.0, -1.0, -1.0);
Assert.AreEqual(1, color2.A, "A is not 1");
Assert.AreEqual(0, color2.R, "R is not 0");
Assert.AreEqual(0, color2.G, "G is not 0");
Assert.AreEqual(0, color2.B, "B is not 0");
}
[TestMethod]
public void ARGBPercentConstructorClampTest()
{
Core.Color color1 = new Core.Color(1.1, 1.1, 1.1, 1.1);
Assert.AreEqual(1, color1.A, "A is not 1");
Assert.AreEqual(1, color1.R, "R is not 1");
Assert.AreEqual(1, color1.G, "G is not 1");
Assert.AreEqual(1, color1.B, "B is not 1");
Core.Color color2 = new Core.Color(-1.0, -1.0, -1.0, -1.0);
Assert.AreEqual(0, color2.A, "A is not 0");
Assert.AreEqual(0, color2.R, "R is not 0");
Assert.AreEqual(0, color2.G, "G is not 0");
Assert.AreEqual(0, color2.B, "B is not 0");
}
[TestMethod]
public void CloneConstructorTest()
{
Core.Color referennceColor = new Core.Color(200, 10, 120, 255);
Core.Color color = new Core.Color(referennceColor);
Assert.AreEqual(200, color.GetA(), "A is not 200");
Assert.AreEqual(10, color.GetR(), "R is not 10");
Assert.AreEqual(120, color.GetG(), "G is not 120");
Assert.AreEqual(255, color.GetB(), "B is not 255");
}
#endregion
#region Conversion
[TestMethod]
public void ColorFromComponentsTest()
{
Core.Color color = (255, 120, 13, 1);
Assert.AreEqual(255, color.GetA(), $"A doesn't equal the used component. ({color.GetA()} != 255)");
Assert.AreEqual(120, color.GetR(), $"R doesn't equal the used component. ({color.GetR()} != 120)");
Assert.AreEqual(13, color.GetG(), $"G doesn't equal the used component. ({color.GetG()} != 13)");
Assert.AreEqual(1, color.GetB(), $"B doesn't equal the used component. ({color.GetB()} != 1)");
}
[TestMethod]
public void DesconstructTest()
{
(byte a, byte r, byte g, byte b) = new Core.Color(255, 120, 13, 1).GetRGBBytes();
Assert.AreEqual(255, a, $"A doesn't equal the color. ({a} != 255)");
Assert.AreEqual(120, r, $"R doesn't equal the color. ({r} != 120)");
Assert.AreEqual(13, g, $"G doesn't equal the color. ({g} != 13)");
Assert.AreEqual(1, b, $"B doesn't equal the color. ({b} != 1)");
}
[TestMethod]
public void AToPercentTest()
{
Core.Color color1 = new Core.Color(0, 0, 0, 0);
Assert.AreEqual(0, color1.A);
Core.Color color2 = new Core.Color(255, 0, 0, 0);
Assert.AreEqual(1, color2.A);
Core.Color color3 = new Core.Color(128, 0, 0, 0);
Assert.AreEqual(128 / 255.0, color3.A);
Core.Color color4 = new Core.Color(30, 0, 0, 0);
Assert.AreEqual(30 / 255.0, color4.A);
Core.Color color5 = new Core.Color(201, 0, 0, 0);
Assert.AreEqual(201 / 255.0, color5.A);
}
[TestMethod]
public void RToPercentTest()
{
Core.Color color1 = new Core.Color(0, 0, 0, 0);
Assert.AreEqual(0, color1.R);
Core.Color color2 = new Core.Color(0, 255, 0, 0);
Assert.AreEqual(1, color2.R);
Core.Color color3 = new Core.Color(0, 128, 0, 0);
Assert.AreEqual(128 / 255.0, color3.R);
Core.Color color4 = new Core.Color(0, 30, 0, 0);
Assert.AreEqual(30 / 255.0, color4.R);
Core.Color color5 = new Core.Color(0, 201, 0, 0);
Assert.AreEqual(201 / 255.0, color5.R);
}
[TestMethod]
public void GToPercentTest()
{
Core.Color color1 = new Core.Color(0, 0, 0, 0);
Assert.AreEqual(0, color1.G);
Core.Color color2 = new Core.Color(0, 0, 255, 0);
Assert.AreEqual(1, color2.G);
Core.Color color3 = new Core.Color(0, 0, 128, 0);
Assert.AreEqual(128 / 255.0, color3.G);
Core.Color color4 = new Core.Color(0, 0, 30, 0);
Assert.AreEqual(30 / 255.0, color4.G);
Core.Color color5 = new Core.Color(0, 0, 201, 0);
Assert.AreEqual(201 / 255.0, color5.G);
}
[TestMethod]
public void BToPercentTest()
{
Core.Color color1 = new Core.Color(0, 0, 0, 0);
Assert.AreEqual(0, color1.B);
Core.Color color2 = new Core.Color(0, 0, 0, 255);
Assert.AreEqual(1, color2.B);
Core.Color color3 = new Core.Color(0, 0, 0, 128);
Assert.AreEqual(128 / 255.0, color3.B);
Core.Color color4 = new Core.Color(0, 0, 0, 30);
Assert.AreEqual(30 / 255.0, color4.B);
Core.Color color5 = new Core.Color(0, 0, 0, 201);
Assert.AreEqual(201 / 255.0, color5.B);
}
#endregion
}
}

284
Tests/RGB.NET.Core.Tests/Color/HSVColorTest.cs Normal file
View File

@ -0,0 +1,284 @@
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace RGB.NET.Core.Tests.Color
{
[TestClass]
public class HSVColorTest
{
#region Manipulation
#region Add
[TestMethod]
public void AddHueTest()
{
Core.Color baseColor = HSVColor.Create(180, 0.5, 0.5);
Core.Color result = baseColor.AddHSV(hue: 30);
Assert.AreEqual(HSVColor.Create(210, 0.5, 0.5), result);
}
[TestMethod]
public void AddHueWrapTest()
{
Core.Color baseColor = HSVColor.Create(180, 0.5, 0.5);
Core.Color result = baseColor.AddHSV(hue: 220);
Assert.AreEqual(HSVColor.Create(40, 0.5, 0.5), result);
}
[TestMethod]
public void AddSaturationTest()
{
Core.Color baseColor = HSVColor.Create(180, 0.5, 0.5);
Core.Color result = baseColor.AddHSV(saturation: 0.3);
Assert.AreEqual(HSVColor.Create(180, 0.8, 0.5), result);
}
[TestMethod]
public void AddSaturationClampTest()
{
Core.Color baseColor = HSVColor.Create(180, 0.5, 0.5);
Core.Color result = baseColor.AddHSV(saturation: 0.8);
Assert.AreEqual(HSVColor.Create(180, 1.0, 0.5), result);
}
[TestMethod]
public void AddValueTest()
{
Core.Color baseColor = HSVColor.Create(180, 0.5, 0.5);
Core.Color result = baseColor.AddHSV(value: 0.3);
Assert.AreEqual(HSVColor.Create(180, 0.5, 0.8), result);
}
[TestMethod]
public void AddValueClampTest()
{
Core.Color baseColor = HSVColor.Create(180, 0.5, 0.5);
Core.Color result = baseColor.AddHSV(value: 0.8);
Assert.AreEqual(HSVColor.Create(180, 0.5, 1.0), result);
}
#endregion
#region Subtract
[TestMethod]
public void SubtractHueTest()
{
Core.Color baseColor = HSVColor.Create(180, 0.5, 0.5);
Core.Color result = baseColor.SubtractHSV(hue: 30);
Assert.AreEqual(HSVColor.Create(150, 0.5, 0.5), result);
}
[TestMethod]
public void SubtractHueWrapTest()
{
Core.Color baseColor = HSVColor.Create(180, 0.5, 0.5);
Core.Color result = baseColor.SubtractHSV(hue: 220);
Assert.AreEqual(HSVColor.Create(320, 0.5, 0.5), result);
}
[TestMethod]
public void SubtractSaturationTest()
{
Core.Color baseColor = HSVColor.Create(180, 0.5, 0.5);
Core.Color result = baseColor.SubtractHSV(saturation: 0.3);
Assert.AreEqual(HSVColor.Create(180, 0.2, 0.5), result);
}
[TestMethod]
public void SubtractSaturationClampTest()
{
Core.Color baseColor = HSVColor.Create(180, 0.5, 0.5);
Core.Color result = baseColor.SubtractHSV(saturation: 0.8);
Assert.AreEqual(HSVColor.Create(180, 0, 0.5), result);
}
[TestMethod]
public void SubtractValueTest()
{
Core.Color baseColor = HSVColor.Create(180, 0.5, 0.5);
Core.Color result = baseColor.SubtractHSV(value: 0.3);
Assert.AreEqual(HSVColor.Create(180, 0.5, 0.2), result);
}
[TestMethod]
public void SubtractValueClampTest()
{
Core.Color baseColor = HSVColor.Create(180, 0.5, 0.5);
Core.Color result = baseColor.SubtractHSV(value: .8);
Assert.AreEqual(HSVColor.Create(180, 0.5, 0), result);
}
#endregion
#region Multiply
[TestMethod]
public void MultiplyHueTest()
{
Core.Color baseColor = HSVColor.Create(180, 0.5, 0.5);
Core.Color result = baseColor.MultiplyHSV(hue: 1.5);
Assert.AreEqual(HSVColor.Create(270, 0.5, 0.5), result);
}
[TestMethod]
public void MultiplyHueWrapTest()
{
Core.Color baseColor = HSVColor.Create(180, 0.5, 0.5);
Core.Color result = baseColor.MultiplyHSV(hue: 3);
Assert.AreEqual(HSVColor.Create(180, 0.5, 0.5), result);
}
[TestMethod]
public void MultiplySaturationTest()
{
Core.Color baseColor = HSVColor.Create(180, 0.2, 0.2);
Core.Color result = baseColor.MultiplyHSV(saturation: 3);
Assert.AreEqual(HSVColor.Create(180, 0.6, 0.2), result);
}
[TestMethod]
public void MultiplySaturationClampTest()
{
Core.Color baseColor = HSVColor.Create(180, 0.5, 0.5);
Core.Color result = baseColor.MultiplyHSV(saturation: 3);
Assert.AreEqual(HSVColor.Create(180, 1.0, 0.5), result);
}
[TestMethod]
public void MultiplyValueTest()
{
Core.Color baseColor = HSVColor.Create(180, 0.2, 0.2);
Core.Color result = baseColor.MultiplyHSV(value: 3);
Assert.AreEqual(HSVColor.Create(180, 0.2, 0.6), result);
}
[TestMethod]
public void MultiplyValueClampTest()
{
Core.Color baseColor = HSVColor.Create(180, 0.5, 0.5);
Core.Color result = baseColor.MultiplyHSV(value: 3);
Assert.AreEqual(HSVColor.Create(180, 0.5, 1.0), result);
}
#endregion
#region Divide
[TestMethod]
public void DivideHueTest()
{
Core.Color baseColor = HSVColor.Create(180, 0.5, 0.5);
Core.Color result = baseColor.DivideHSV(hue: 30);
Assert.AreEqual(HSVColor.Create(6, 0.5, 0.5), result);
}
[TestMethod]
public void DivideSaturationTest()
{
Core.Color baseColor = HSVColor.Create(180, 0.6, 0.6);
Core.Color result = baseColor.DivideHSV(saturation: 2);
Assert.AreEqual(HSVColor.Create(180, 0.3, 0.6), result);
}
[TestMethod]
public void DivideValueTest()
{
Core.Color baseColor = HSVColor.Create(180, 0.6, 0.6);
Core.Color result = baseColor.DivideHSV(value: 2);
Assert.AreEqual(HSVColor.Create(180, 0.6, 0.3), result);
}
#endregion
#region Set
[TestMethod]
public void SetHueTest()
{
Core.Color baseColor = HSVColor.Create(180, 0.5, 0.5);
Core.Color result = baseColor.SetHSV(hue: 30);
Assert.AreEqual(HSVColor.Create(30, 0.5, 0.5), result);
}
[TestMethod]
public void SetHueWrapTest()
{
Core.Color baseColor = HSVColor.Create(180, 0.5, 0.5);
Core.Color result = baseColor.SetHSV(hue: 440);
Assert.AreEqual(HSVColor.Create(80, 0.5, 0.5), result);
}
[TestMethod]
public void SetHueWrapNegativeTest()
{
Core.Color baseColor = HSVColor.Create(180, 0.5, 0.5);
Core.Color result = baseColor.SetHSV(hue: -30);
Assert.AreEqual(HSVColor.Create(330, 0.5, 0.5), result);
}
[TestMethod]
public void SetSaturationTest()
{
Core.Color baseColor = HSVColor.Create(180, 0.5, 0.5);
Core.Color result = baseColor.SetHSV(saturation: 0.3);
Assert.AreEqual(HSVColor.Create(180, 0.3, 0.5), result);
}
[TestMethod]
public void SetSaturationClampTest()
{
Core.Color baseColor = HSVColor.Create(180, 0.5, 0.5);
Core.Color result = baseColor.SetHSV(saturation: 2);
Assert.AreEqual(HSVColor.Create(180, 1.0, 0.5), result);
}
[TestMethod]
public void SetValueTest()
{
Core.Color baseColor = HSVColor.Create(180, 0.5, 0.5);
Core.Color result = baseColor.SetHSV(value: 0.3);
Assert.AreEqual(HSVColor.Create(180, 0.5, 0.3), result);
}
[TestMethod]
public void SetValueClampTest()
{
Core.Color baseColor = HSVColor.Create(180, 0.5, 0.5);
Core.Color result = baseColor.SetHSV(value: 2);
Assert.AreEqual(HSVColor.Create(180, 0.5, 1.0), result);
}
#endregion
#endregion
}
}

432
Tests/RGB.NET.Core.Tests/Color/RGBColorTest.cs Normal file
View File

@ -0,0 +1,432 @@
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace RGB.NET.Core.Tests.Color
{
[TestClass]
public class RGBColorTest
{
#region Manipulation
#region Blend
[TestMethod]
public void BlendOpaqueTest()
{
Core.Color baseColor = new Core.Color(255, 0, 0);
Core.Color blendColor = new Core.Color(0, 255, 0);
Assert.AreEqual(blendColor, baseColor.Blend(blendColor));
}
[TestMethod]
public void BlendTransparentTest()
{
Core.Color baseColor = new Core.Color(255, 0, 0);
Core.Color blendColor = new Core.Color(0, 0, 255, 0);
Assert.AreEqual(baseColor, baseColor.Blend(blendColor));
}
[TestMethod]
public void BlendUpTest()
{
Core.Color baseColor = new Core.Color(0.0, 0.0, 0.0);
Core.Color blendColor = new Core.Color(0.5, 1.0, 1.0, 1.0);
Assert.AreEqual(new Core.Color(0.5, 0.5, 0.5), baseColor.Blend(blendColor));
}
[TestMethod]
public void BlendDownTest()
{
Core.Color baseColor = new Core.Color(1.0, 1.0, 1.0);
Core.Color blendColor = new Core.Color(0.5, 0.0, 0.0, 0.0);
Assert.AreEqual(new Core.Color(0.5, 0.5, 0.5), baseColor.Blend(blendColor));
}
#endregion
#region Add
[TestMethod]
public void AddRGBTest()
{
Core.Color baseColor = new Core.Color(128, 128, 128, 128);
Core.Color result = baseColor.AddRGB(11, 12, 13);
Assert.AreEqual(new Core.Color(128, 139, 140, 141), result);
}
[TestMethod]
public void AddRGBPercentTest()
{
Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5);
Core.Color result = baseColor.AddRGB(0.2, 0.3, 0.4);
Assert.AreEqual(new Core.Color(0.5, 0.7, 0.8, 0.9), result);
}
[TestMethod]
public void AddATest()
{
Core.Color baseColor = new Core.Color(128, 128, 128, 128);
Core.Color result = baseColor.AddA(10);
Assert.AreEqual(new Core.Color(138, 128, 128, 128), result);
}
[TestMethod]
public void AddAPercentTest()
{
Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5);
Core.Color result = baseColor.AddA(0.1);
Assert.AreEqual(new Core.Color(0.6, 0.5, 0.5, 0.5), result);
}
[TestMethod]
public void AddRTest()
{
Core.Color baseColor = new Core.Color(128, 128, 128, 128);
Core.Color result = baseColor.AddRGB(r: 10);
Assert.AreEqual(new Core.Color(128, 138, 128, 128), result);
}
[TestMethod]
public void AddRPercentTest()
{
Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5);
Core.Color result = baseColor.AddRGB(r: 0.1);
Assert.AreEqual(new Core.Color(0.5, 0.6, 0.5, 0.5), result);
}
[TestMethod]
public void AddGTest()
{
Core.Color baseColor = new Core.Color(128, 128, 128, 128);
Core.Color result = baseColor.AddRGB(g: 10);
Assert.AreEqual(new Core.Color(128, 128, 138, 128), result);
}
[TestMethod]
public void AddGPercentTest()
{
Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5);
Core.Color result = baseColor.AddRGB(g: 0.1);
Assert.AreEqual(new Core.Color(0.5, 0.5, 0.6, 0.5), result);
}
[TestMethod]
public void AddBTest()
{
Core.Color baseColor = new Core.Color(128, 128, 128, 128);
Core.Color result = baseColor.AddRGB(b: 10);
Assert.AreEqual(new Core.Color(128, 128, 128, 138), result);
}
[TestMethod]
public void AddBPercentTest()
{
Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5);
Core.Color result = baseColor.AddRGB(b: 0.1);
Assert.AreEqual(new Core.Color(0.5, 0.5, 0.5, 0.6), result);
}
#endregion
#region Substract
[TestMethod]
public void SubtractRGBTest()
{
Core.Color baseColor = new Core.Color(128, 128, 128, 128);
Core.Color result = baseColor.SubtractRGB(11, 12, 13);
Assert.AreEqual(new Core.Color(128, 117, 116, 115), result);
}
[TestMethod]
public void SubtractRGBPercentTest()
{
Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5);
Core.Color result = baseColor.SubtractRGB(0.2, 0.3, 0.4);
Assert.AreEqual(new Core.Color(0.5, 0.3, 0.2, 0.1), result);
}
[TestMethod]
public void SubtractATest()
{
Core.Color baseColor = new Core.Color(128, 128, 128, 128);
Core.Color result = baseColor.SubtractA(10);
Assert.AreEqual(new Core.Color(118, 128, 128, 128), result);
}
[TestMethod]
public void SubtractAPercentTest()
{
Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5);
Core.Color result = baseColor.SubtractA(0.1);
Assert.AreEqual(new Core.Color(0.4, 0.5, 0.5, 0.5), result);
}
[TestMethod]
public void SubtractRTest()
{
Core.Color baseColor = new Core.Color(128, 128, 128, 128);
Core.Color result = baseColor.SubtractRGB(r: 10);
Assert.AreEqual(new Core.Color(128, 118, 128, 128), result);
}
[TestMethod]
public void SubtractRPercentTest()
{
Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5);
Core.Color result = baseColor.SubtractRGB(r: 0.1);
Assert.AreEqual(new Core.Color(0.5, 0.4, 0.5, 0.5), result);
}
[TestMethod]
public void SubtractGTest()
{
Core.Color baseColor = new Core.Color(128, 128, 128, 128);
Core.Color result = baseColor.SubtractRGB(g: 10);
Assert.AreEqual(new Core.Color(128, 128, 118, 128), result);
}
[TestMethod]
public void SubtractGPercentTest()
{
Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5);
Core.Color result = baseColor.SubtractRGB(g: 0.1);
Assert.AreEqual(new Core.Color(0.5, 0.5, 0.4, 0.5), result);
}
[TestMethod]
public void SubtractBTest()
{
Core.Color baseColor = new Core.Color(128, 128, 128, 128);
Core.Color result = baseColor.SubtractRGB(b: 10);
Assert.AreEqual(new Core.Color(128, 128, 128, 118), result);
}
[TestMethod]
public void SubtractBPercentTest()
{
Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5);
Core.Color result = baseColor.SubtractRGB(b: 0.1);
Assert.AreEqual(new Core.Color(0.5, 0.5, 0.5, 0.4), result);
}
#endregion
#region Multiply
[TestMethod]
public void MultiplyRGBPercentTest()
{
Core.Color baseColor = new Core.Color(0.2, 0.2, 0.2, 0.2);
Core.Color result = baseColor.MultiplyRGB(3, 4, 5);
Assert.AreEqual(new Core.Color(0.2, 0.6, 0.8, 1.0), result);
}
[TestMethod]
public void MultiplyAPercentTest()
{
Core.Color baseColor = new Core.Color(0.2, 0.2, 0.2, 0.2);
Core.Color result = baseColor.MultiplyA(3);
Assert.AreEqual(new Core.Color(0.6, 0.2, 0.2, 0.2), result);
}
[TestMethod]
public void MultiplyRPercentTest()
{
Core.Color baseColor = new Core.Color(0.2, 0.2, 0.2, 0.2);
Core.Color result = baseColor.MultiplyRGB(r: 3);
Assert.AreEqual(new Core.Color(0.2, 0.6, 0.2, 0.2), result);
}
[TestMethod]
public void MultiplyGPercentTest()
{
Core.Color baseColor = new Core.Color(0.2, 0.2, 0.2, 0.2);
Core.Color result = baseColor.MultiplyRGB(g: 3);
Assert.AreEqual(new Core.Color(0.2, 0.2, 0.6, 0.2), result);
}
[TestMethod]
public void MultiplyBPercentTest()
{
Core.Color baseColor = new Core.Color(0.2, 0.2, 0.2, 0.2);
Core.Color result = baseColor.MultiplyRGB(b: 3);
Assert.AreEqual(new Core.Color(0.2, 0.2, 0.2, 0.6), result);
}
#endregion
#region Divide
[TestMethod]
public void DivideRGBPercentTest()
{
Core.Color baseColor = new Core.Color(0.2, 0.6, 0.8, 1.0);
Core.Color result = baseColor.DivideRGB(3, 4, 5);
Assert.AreEqual(new Core.Color(0.2, 0.2, 0.2, 0.2), result);
}
[TestMethod]
public void DivideAPercentTest()
{
Core.Color baseColor = new Core.Color(0.6, 0.2, 0.2, 0.2);
Core.Color result = baseColor.DivideA(3);
Assert.AreEqual(new Core.Color(0.2, 0.2, 0.2, 0.2), result);
}
[TestMethod]
public void DivideRPercentTest()
{
Core.Color baseColor = new Core.Color(0.2, 0.6, 0.2, 0.2);
Core.Color result = baseColor.DivideRGB(r: 3);
Assert.AreEqual(new Core.Color(0.2, 0.2, 0.2, 0.2), result);
}
[TestMethod]
public void DivideGPercentTest()
{
Core.Color baseColor = new Core.Color(0.2, 0.2, 0.6, 0.2);
Core.Color result = baseColor.DivideRGB(g: 3);
Assert.AreEqual(new Core.Color(0.2, 0.2, 0.2, 0.2), result);
}
[TestMethod]
public void DivideBPercentTest()
{
Core.Color baseColor = new Core.Color(0.2, 0.2, 0.2, 0.6);
Core.Color result = baseColor.DivideRGB(b: 3);
Assert.AreEqual(new Core.Color(0.2, 0.2, 0.2, 0.2), result);
}
#endregion
#region Set
[TestMethod]
public void SetRGBTest()
{
Core.Color baseColor = new Core.Color(128, 128, 128, 128);
Core.Color result = baseColor.SetRGB(11, 12, 13);
Assert.AreEqual(new Core.Color(128, 11, 12, 13), result);
}
[TestMethod]
public void SetRGBPercentTest()
{
Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5);
Core.Color result = baseColor.SetRGB(0.2, 0.3, 0.4);
Assert.AreEqual(new Core.Color(0.5, 0.2, 0.3, 0.4), result);
}
[TestMethod]
public void SetATest()
{
Core.Color baseColor = new Core.Color(128, 128, 128, 128);
Core.Color result = baseColor.SetA(10);
Assert.AreEqual(new Core.Color(10, 128, 128, 128), result);
}
[TestMethod]
public void SetAPercentTest()
{
Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5);
Core.Color result = baseColor.SetA(0.1);
Assert.AreEqual(new Core.Color(0.1, 0.5, 0.5, 0.5), result);
}
[TestMethod]
public void SetRTest()
{
Core.Color baseColor = new Core.Color(128, 128, 128, 128);
Core.Color result = baseColor.SetRGB(r: 10);
Assert.AreEqual(new Core.Color(128, 10, 128, 128), result);
}
[TestMethod]
public void SetRPercentTest()
{
Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5);
Core.Color result = baseColor.SetRGB(r: 0.1);
Assert.AreEqual(new Core.Color(0.5, 0.1, 0.5, 0.5), result);
}
[TestMethod]
public void SetGTest()
{
Core.Color baseColor = new Core.Color(128, 128, 128, 128);
Core.Color result = baseColor.SetRGB(g: 10);
Assert.AreEqual(new Core.Color(128, 128, 10, 128), result);
}
[TestMethod]
public void SetGPercentTest()
{
Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5);
Core.Color result = baseColor.SetRGB(g: 0.1);
Assert.AreEqual(new Core.Color(0.5, 0.5, 0.1, 0.5), result);
}
[TestMethod]
public void SetBTest()
{
Core.Color baseColor = new Core.Color(128, 128, 128, 128);
Core.Color result = baseColor.SetRGB(b: 10);
Assert.AreEqual(new Core.Color(128, 128, 128, 10), result);
}
[TestMethod]
public void SetBPercentTest()
{
Core.Color baseColor = new Core.Color(0.5, 0.5, 0.5, 0.5);
Core.Color result = baseColor.SetRGB(b: 0.1);
Assert.AreEqual(new Core.Color(0.5, 0.5, 0.5, 0.1), result);
}
#endregion
#endregion
}
}

19
Tests/RGB.NET.Core.Tests/RGB.NET.Core.Tests.csproj Normal file
View File

@ -0,0 +1,19 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>netcoreapp2.2</TargetFramework>
<IsPackable>false</IsPackable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.9.0" />
<PackageReference Include="MSTest.TestAdapter" Version="1.3.2" />
<PackageReference Include="MSTest.TestFramework" Version="1.3.2" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\..\RGB.NET.Core\RGB.NET.Core.csproj" />
</ItemGroup>
</Project>