public void Convert_HunterLab_to_CieXyy(float l, float a, float b, float x, float y, float yl)
{
// Arrange
var input = new HunterLab(l, a, b);
var expected = new CieXyy(x, y, yl);
Span <HunterLab> inputSpan = new HunterLab[5];
inputSpan.Fill(input);
Span <CieXyy> actualSpan = new CieXyy[5];
// Act
CieXyy actual = Converter.ToCieXyy(input);
Converter.Convert(inputSpan, actualSpan);
// Assert
Assert.Equal(expected, actual, ColorSpaceComparer);
for (int i = 0; i < actualSpan.Length; i++)
{
Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
}
}
public void Convert_HunterLab_to_Cmyk(float l, float a, float b, float c, float m, float y, float k)
{
// Arrange
var input = new HunterLab(l, a, b);
var expected = new Cmyk(c, m, y, k);
Span <HunterLab> inputSpan = new HunterLab[5];
inputSpan.Fill(input);
Span <Cmyk> actualSpan = new Cmyk[5];
// Act
var actual = Converter.ToCmyk(input);
Converter.Convert(inputSpan, actualSpan);
// Assert
Assert.Equal(expected, actual, ColorSpaceComparer);
for (int i = 0; i < actualSpan.Length; i++)
{
Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
}
}
[InlineData(0.95047, 1, 1.08883, 100, 0, 0)] // D65 white point is HunterLab 100, 0, 0 (adaptation to C performed)
public void Convert_Xyz_D65_to_HunterLab(float x, float y, float z, float l, float a, float b)
{
// Arrange
var input = new CieXyz(x, y, z);
var options = new ColorSpaceConverterOptions {
WhitePoint = Illuminants.D65
};
var converter = new ColorSpaceConverter(options);
var expected = new HunterLab(l, a, b);
Span <CieXyz> inputSpan = new CieXyz[5];
inputSpan.Fill(input);
Span <HunterLab> actualSpan = new HunterLab[5];
// Act
var actual = converter.ToHunterLab(input);
converter.Convert(inputSpan, actualSpan, actualSpan.Length);
// Assert
Assert.Equal(expected, actual, ColorSpaceComparer);
for (int i = 0; i < actualSpan.Length; i++)
{
Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
}
}
public void Convert_CieLuv_to_HunterLab(float l, float u, float v, float l2, float a, float b)
{
// Arrange
var input = new CieLuv(l, u, v);
var expected = new HunterLab(l2, a, b);
Span <CieLuv> inputSpan = new CieLuv[5];
inputSpan.Fill(input);
Span <HunterLab> actualSpan = new HunterLab[5];
// Act
var actual = Converter.ToHunterLab(input);
Converter.Convert(inputSpan, actualSpan);
// Assert
Assert.Equal(expected, actual, ColorSpaceComparer);
for (int i = 0; i < actualSpan.Length; i++)
{
Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
}
}
public void Convert_HunterLab_to_CieLch(float l2, float a, float b, float l, float c, float h)
{
// Arrange
var input = new HunterLab(l2, a, b);
var expected = new CieLch(l, c, h);
Span <HunterLab> inputSpan = new HunterLab[5];
inputSpan.Fill(input);
Span <CieLch> actualSpan = new CieLch[5];
// Act
var actual = Converter.ToCieLch(input);
Converter.Convert(inputSpan, actualSpan);
// Assert
Assert.Equal(expected, actual, ColorSpaceComparer);
for (int i = 0; i < actualSpan.Length; i++)
{
Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
}
}
/// <summary>
/// Converts a <see cref="HunterLab"/> into a <see cref="YCbCr"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="YCbCr"/></returns>
public YCbCr ToYCbCr(HunterLab color)
{
Guard.NotNull(color, nameof(color));
var xyzColor = this.ToCieXyz(color);
return(this.ToYCbCr(xyzColor));
}
/// <summary>
/// Converts a <see cref="HunterLab"/> into a <see cref="LinearRgb"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="LinearRgb"/></returns>
public LinearRgb ToLinearRgb(HunterLab color)
{
Guard.NotNull(color, nameof(color));
var xyzColor = this.ToCieXyz(color);
return(this.ToLinearRgb(xyzColor));
}
/// <summary>
/// Converts a <see cref="HunterLab"/> into a <see cref="CieLchuv"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="CieLchuv"/></returns>
public CieLchuv ToCieLchuv(HunterLab color)
{
Guard.NotNull(color, nameof(color));
CieXyz xyzColor = this.ToCieXyz(color);
return(this.ToCieLchuv(xyzColor));
}
/// <summary>
/// Converts a <see cref="HunterLab"/> into a <see cref="Lms"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="Lms"/></returns>
public Lms ToLms(HunterLab color)
{
Guard.NotNull(color, nameof(color));
var xyzColor = this.ToCieXyz(color);
return(this.ToLms(xyzColor));
}
public void SalmonHunterLabToHex()
{
var knownColor = new HunterLab {
L = 60.809, A = 40.886, B = 22.664,
};
var expectedColor = new Hex("FA8072");
ExpectedValuesForKnownColor(knownColor, expectedColor);
}
public void SalmonHunterLabToMunsell()
{
var knownColor = new HunterLab {
L = 60.809, A = 40.886, B = 22.664,
};
var expectedColor = new Munsell("7.5R 7/12");
ExpectedValuesForKnownColor(knownColor, expectedColor);
}
public void BabyBlueHunterLabToXyz()
{
var knownColor = new HunterLab {
L = 85.308, A = -27.915, B = -13.675,
};
var expectedColor = new Xyz {
X = 58.007, Y = 72.775, Z = 105.596,
};
ExpectedValuesForKnownColor(knownColor, expectedColor);
}
public void BlackRgbToHunterLab()
{
var knownColor = new Rgb {
R = 0, G = 0, B = 0,
};
var expectedColor = new HunterLab {
L = 0, A = 0, B = 0,
};
ExpectedValuesForKnownColor(knownColor, expectedColor);
}
public void HunterLabConstructorAssignsFields()
{
const float l = 75F;
const float a = -64F;
const float b = 87F;
var hunterLab = new HunterLab(l, a, b);
Assert.Equal(l, hunterLab.L);
Assert.Equal(a, hunterLab.A);
Assert.Equal(b, hunterLab.B);
}
public void GoldenrodRgbToHunterLab()
{
var knownColor = new Rgb {
R = 218, G = 165, B = 32,
};
var expectedColor = new HunterLab {
L = 64.746, A = 4.222, B = 38.719,
};
ExpectedValuesForKnownColor(knownColor, expectedColor);
}
public void BabyBlueHunterLabToRgb()
{
var knownColor = new HunterLab {
L = 85.308, A = -27.915, B = -13.675,
};
var expectedColor = new Rgb {
R = 133, G = 237, B = 255,
};
ExpectedValuesForKnownColor(knownColor, expectedColor);
}
public void WhiteRgbToHunterLab()
{
var knownColor = new Rgb {
R = 255, G = 255, B = 255,
};
var expectedColor = new HunterLab {
L = 100, A = -5.336, B = 5.433,
};
ExpectedValuesForKnownColor(knownColor, expectedColor);
}
/// <summary>
/// Converts a <see cref="HunterLab"/> into a <see cref="CieXyz"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="CieXyz"/></returns>
public CieXyz ToCieXyz(HunterLab color)
{
// Conversion
CieXyz unadapted = HunterLabToCieXyzConverter.Convert(color);
// Adaptation
CieXyz adapted = color.WhitePoint.Equals(this.WhitePoint) || !this.IsChromaticAdaptationPerformed
? unadapted
: this.Adapt(unadapted, color.WhitePoint);
return(adapted);
}
public void HunterLabEquality()
{
var x = default(HunterLab);
var y = new HunterLab(Vector3.One);
Assert.True(default(HunterLab) == default(HunterLab));
Assert.True(new HunterLab(1, 0, 1) != default(HunterLab));
Assert.False(new HunterLab(1, 0, 1) == default(HunterLab));
Assert.Equal(default(HunterLab), default(HunterLab));
Assert.Equal(new HunterLab(1, 0, 1), new HunterLab(1, 0, 1));
Assert.Equal(new HunterLab(Vector3.One), new HunterLab(Vector3.One));
Assert.False(x.Equals(y));
Assert.False(x.Equals((object)y));
Assert.False(x.GetHashCode().Equals(y.GetHashCode()));
}
/// <summary>
/// Adapts <see cref="HunterLab"/> color from the source white point to white point set in <see cref="TargetHunterLabWhitePoint"/>.
/// </summary>
/// <param name="color">The color to adapt</param>
/// <returns>The adapted color</returns>
public HunterLab Adapt(HunterLab color)
{
if (!this.IsChromaticAdaptationPerformed)
{
throw new InvalidOperationException("Cannot perform chromatic adaptation, provide a chromatic adaptation method and white point.");
}
if (color.WhitePoint.Equals(this.TargetHunterLabWhitePoint))
{
return(color);
}
CieXyz xyzColor = this.ToCieXyz(color);
return(this.ToHunterLab(xyzColor));
}
[InlineData(0.95047, 1, 1.08883, 100, 0, 0)] // D65 white point is HunterLab 100, 0, 0 (adaptation to C performed)
public void Convert_Xyz_D65_to_HunterLab(float x, float y, float z, float l, float a, float b)
{
// Arrange
CieXyz input = new CieXyz(x, y, z);
ColorSpaceConverter converter = new ColorSpaceConverter {
WhitePoint = Illuminants.D65
};
// Act
HunterLab output = converter.ToHunterLab(input);
// Assert
Assert.Equal(l, output.L, FloatRoundingComparer);
Assert.Equal(a, output.A, FloatRoundingComparer);
Assert.Equal(b, output.B, FloatRoundingComparer);
}
public void Adapt_HunterLab_D65_To_D50(float l1, float a1, float b1, float l2, float a2, float b2)
{
// Arrange
var input = new HunterLab(l1, a1, b1, Illuminants.D65);
var expected = new HunterLab(l2, a2, b2);
var options = new ColorSpaceConverterOptions {
TargetLabWhitePoint = Illuminants.D50
};
var converter = new ColorSpaceConverter(options);
// Action
HunterLab actual = converter.Adapt(input);
// Assert
Assert.Equal(expected, actual, ColorSpaceComparer);
}
[InlineData(100, 0, 0, 0.95047, 1, 1.08883)] // D65 white point is HunerLab 100, 0, 0 (adaptation to C performed)
public void Convert_HunterLab_to_Xyz_D65(float l, float a, float b, float x, float y, float z)
{
// Arrange
HunterLab input = new HunterLab(l, a, b);
ColorSpaceConverter converter = new ColorSpaceConverter {
WhitePoint = Illuminants.D65
};
// Act
CieXyz output = converter.ToCieXyz(input);
// Assert
Assert.Equal(x, output.X, FloatRoundingComparer);
Assert.Equal(y, output.Y, FloatRoundingComparer);
Assert.Equal(z, output.Z, FloatRoundingComparer);
}
/// ------------------------------------------------------------------------------------
public XYZ Convert(HunterLab input)
{
double L = input.L, a = input.a, b = input.b;
double Xn = input.Illuminant.X, Yn = input.Illuminant.Y, Zn = input.Illuminant.Z;
var Ka = XYZ.ComputeKa(input.Illuminant);
var Kb = XYZ.ComputeKb(input.Illuminant);
var Y = (L / 100d).Power(2) * Yn;
var X = ((a / Ka) * Math.Sqrt(Y / Yn) + Y / Yn) * Xn;
var Z = ((b / Kb) * Math.Sqrt(Y / Yn) - Y / Yn) * (-Zn);
var result = new XYZ(X, Y, Z);
return(result);
}
/// <summary>
/// Converts a <see cref="HunterLab"/> into a <see cref="YCbCr"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="YCbCr"/></returns>
public YCbCr ToYCbCr(HunterLab color)
{
var xyzColor = this.ToCieXyz(color);
return(this.ToYCbCr(xyzColor));
}
/// <summary>
/// Converts a <see cref="HunterLab"/> into a <see cref="CieLch"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="CieLch"/></returns>
public CieLch ToCieLch(HunterLab color)
{
CieXyz xyzColor = this.ToCieXyz(color);
return(this.ToCieLch(xyzColor));
}
/// <summary>
/// Converts a <see cref="HunterLab"/> into a <see cref="Cmyk"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="Cmyk"/></returns>
public Cmyk ToCmyk(HunterLab color)
{
var xyzColor = this.ToCieXyz(color);
return(this.ToCmyk(xyzColor));
}
/// <summary>
/// Converts a <see cref="HunterLab"/> into a <see cref="CieXyy"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="CieXyy"/></returns>
public CieXyy ToCieXyy(HunterLab color)
{
var xyzColor = this.ToCieXyz(color);
return(this.ToCieXyy(xyzColor));
}
/// <summary>
/// Converts a <see cref="HunterLab"/> into a <see cref="LinearRgb"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="LinearRgb"/></returns>
public LinearRgb ToLinearRgb(HunterLab color)
{
var xyzColor = this.ToCieXyz(color);
return(this.ToLinearRgb(xyzColor));
}
/// <summary>
/// Converts a <see cref="HunterLab"/> into a <see cref="Hsl"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="Hsl"/></returns>
public Hsl ToHsl(HunterLab color)
{
var xyzColor = this.ToCieXyz(color);
return(this.ToHsl(xyzColor));
}
