public void Convert_CieLch_to_CieXyz(float l, float c, float h, float x, float y, float yl)
{
// Arrange
var input = new CieLch(l, c, h);
var expected = new CieXyz(x, y, yl);
Span <CieLch> inputSpan = new CieLch[5];
inputSpan.Fill(input);
Span <CieXyz> actualSpan = new CieXyz[5];
// Act
CieXyz actual = Converter.ToCieXyz(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_YCbCr_to_CieLch(float y, float cb, float cr, float l, float c, float h)
{
// Arrange
var input = new YCbCr(y, cb, cr);
var expected = new CieLch(l, c, h);
Span <YCbCr> inputSpan = new YCbCr[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);
}
}
public void Convert_CieLch_to_Hsv(float l, float c, float h, float h2, float s, float v)
{
// Arrange
var input = new CieLch(l, c, h);
var expected = new Hsv(h2, s, v);
Span <CieLch> inputSpan = new CieLch[5];
inputSpan.Fill(input);
Span <Hsv> actualSpan = new Hsv[5];
// Act
var actual = Converter.ToHsv(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);
}
}
public void Convert_CieLch_to_Cmyk(float l, float c2, float h, float c, float m, float y, float k)
{
// Arrange
var input = new CieLch(l, c2, h);
var expected = new Cmyk(c, m, y, k);
Span <CieLch> inputSpan = new CieLch[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);
}
}
public void Convert_CieLch_to_LinearRgb(float l, float c, float h, float r, float g, float b)
{
// Arrange
var input = new CieLch(l, c, h);
var expected = new LinearRgb(r, g, b);
Span <CieLch> inputSpan = new CieLch[5];
inputSpan.Fill(input);
Span <LinearRgb> actualSpan = new LinearRgb[5];
// Act
var actual = Converter.ToLinearRgb(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_CieLchuv_to_CieLch(float l, float c, float h, float l2, float c2, float h2)
{
// Arrange
var input = new CieLchuv(l, c, h);
var expected = new CieLch(l2, c2, h2);
Span <CieLchuv> inputSpan = new CieLchuv[5];
inputSpan.Fill(input);
Span <CieLch> actualSpan = new CieLch[5];
// Act
var actual = Converter.ToCieLch(input);
Converter.Convert(inputSpan, actualSpan);
// Assert
Assert.Equal(expected, actual, ColorSpaceComparer);
for (int i = 0; i < actualSpan.Length; i++)
{
Assert.Equal(expected, actualSpan[i], ColorSpaceComparer);
}
}
public void Convert_CieLch_to_Lms(float l, float c, float h, float l2, float m, float s)
{
// Arrange
var input = new CieLch(l, c, h);
var expected = new Lms(l2, m, s);
Span <CieLch> inputSpan = new CieLch[5];
inputSpan.Fill(input);
Span <Lms> actualSpan = new Lms[5];
// Act
var actual = Converter.ToLms(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="CieLch"/> into a <see cref="Lms"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="Lms"/></returns>
public Lms ToLms(CieLch color)
{
Guard.NotNull(color, nameof(color));
var xyzColor = this.ToCieXyz(color);
return(this.ToLms(xyzColor));
}
/// <summary>
/// Converts a <see cref="CieLch"/> into a <see cref="CieXyz"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="CieXyz"/></returns>
public CieXyz ToCieXyz(CieLch color)
{
// Conversion to Lab
CieLab labColor = CieLchToCieLabConverter.Convert(color);
// Conversion to XYZ (incl. adaptation)
return(this.ToCieXyz(labColor));
}
/// <summary>
/// Converts a <see cref="CieLch"/> into a <see cref="Cmyk"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="Cmyk"/></returns>
public Cmyk ToCmyk(CieLch color)
{
Guard.NotNull(color, nameof(color));
var xyzColor = this.ToCieXyz(color);
return(this.ToCmyk(xyzColor));
}
/// <summary>
/// Converts a <see cref="CieLch"/> into a <see cref="YCbCr"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="YCbCr"/></returns>
public YCbCr ToYCbCr(CieLch color)
{
Guard.NotNull(color, nameof(color));
var xyzColor = this.ToCieXyz(color);
return(this.ToYCbCr(xyzColor));
}
/// <summary>
/// Converts a <see cref="CieLch"/> into a <see cref="HunterLab"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="HunterLab"/></returns>
public HunterLab ToHunterLab(CieLch color)
{
Guard.NotNull(color, nameof(color));
var xyzColor = this.ToCieXyz(color);
return(this.ToHunterLab(xyzColor));
}
/// <summary>
/// Converts a <see cref="CieLch"/> into a <see cref="CieLchuv"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="CieLchuv"/></returns>
public CieLchuv ToCieLchuv(CieLch color)
{
Guard.NotNull(color, nameof(color));
CieXyz xyzColor = this.ToCieXyz(color);
return(this.ToCieLchuv(xyzColor));
}
/// <summary>
/// Converts a <see cref="CieLch"/> into a <see cref="Hsl"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="Hsl"/></returns>
public Hsl ToHsl(CieLch color)
{
Guard.NotNull(color, nameof(color));
var xyzColor = this.ToCieXyz(color);
return(this.ToHsl(xyzColor));
}
/// <summary>
/// Converts a <see cref="CieLch"/> into a <see cref="LinearRgb"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="LinearRgb"/></returns>
public LinearRgb ToLinearRgb(CieLch color)
{
Guard.NotNull(color, nameof(color));
var xyzColor = this.ToCieXyz(color);
return(this.ToLinearRgb(xyzColor));
}
public void CieLchConstructorAssignsFields()
{
const float l = 75F;
const float c = 64F;
const float h = 287F;
var cieLch = new CieLch(l, c, h);
Assert.Equal(l, cieLch.L);
Assert.Equal(c, cieLch.C);
Assert.Equal(h, cieLch.H);
}
public void Convert_Lch_to_Lab(float l, float c, float h, float l2, float a, float b)
{
// Arrange
CieLch input = new CieLch(l, c, h);
// Act
CieLab output = Converter.ToCieLab(input);
// Assert
Assert.Equal(l2, output.L, FloatRoundingComparer);
Assert.Equal(a, output.A, FloatRoundingComparer);
Assert.Equal(b, output.B, FloatRoundingComparer);
}
public void Convert_Lab_to_LCHab(float l, float a, float b, float l2, float c, float h)
{
// Arrange
CieLab input = new CieLab(l, a, b);
// Act
CieLch output = Converter.ToCieLch(input);
// Assert
Assert.Equal(l2, output.L, FloatRoundingComparer);
Assert.Equal(c, output.C, FloatRoundingComparer);
Assert.Equal(h, output.H, FloatRoundingComparer);
}
/// <summary>
/// Converts a <see cref="CieLch"/> into a <see cref="CieLab"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="CieLab"/></returns>
public CieLab ToCieLab(CieLch color)
{
// Conversion (perserving white point)
CieLab unadapted = CieLchToCieLabConverter.Convert(color);
if (!this.IsChromaticAdaptationPerformed)
{
return(unadapted);
}
// Adaptation
return(this.Adapt(unadapted));
}
public void CieLchEquality()
{
var x = default(CieLch);
var y = new CieLch(Vector3.One);
Assert.True(default(CieLch) == default(CieLch));
Assert.False(default(CieLch) != default(CieLch));
Assert.Equal(default(CieLch), default(CieLch));
Assert.Equal(new CieLch(1, 0, 1), new CieLch(1, 0, 1));
Assert.Equal(new CieLch(Vector3.One), new CieLch(Vector3.One));
Assert.False(x.Equals(y));
Assert.False(x.Equals((object)y));
Assert.False(x.GetHashCode().Equals(y.GetHashCode()));
}
/// <summary>
/// Adapts <see cref="CieLch"/> color from the source white point to white point set in <see cref="TargetLabWhitePoint"/>.
/// </summary>
/// <param name="color">The color to adapt</param>
/// <returns>The adapted color</returns>
public CieLch Adapt(CieLch color)
{
if (!this.IsChromaticAdaptationPerformed)
{
throw new InvalidOperationException("Cannot perform chromatic adaptation, provide a chromatic adaptation method and white point.");
}
if (color.WhitePoint.Equals(this.TargetLabWhitePoint))
{
return(color);
}
CieLab labColor = this.ToCieLab(color);
return(this.ToCieLch(labColor));
}
public void Adapt_CieLch_D65_To_D50_XyzScaling(float l1, float c1, float h1, float l2, float c2, float h2)
{
// Arrange
var input = new CieLch(l1, c1, h1, Illuminants.D65);
var expected = new CieLch(l2, c2, h2);
var options = new ColorSpaceConverterOptions
{
ChromaticAdaptation = new VonKriesChromaticAdaptation(LmsAdaptationMatrix.XyzScaling),
TargetLabWhitePoint = Illuminants.D50
};
var converter = new ColorSpaceConverter(options);
// Action
CieLch actual = converter.Adapt(input);
// Assert
Assert.Equal(expected, actual, ColorSpaceComparer);
}
/// <summary>
/// Converts a <see cref="CieLch"/> into a <see cref="LinearRgb"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="LinearRgb"/></returns>
public LinearRgb ToLinearRgb(CieLch color)
{
var xyzColor = this.ToCieXyz(color);
return(this.ToLinearRgb(xyzColor));
}
/// <summary>
/// Converts a <see cref="CieLch"/> into a <see cref="HunterLab"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="HunterLab"/></returns>
public HunterLab ToHunterLab(CieLch color)
{
var xyzColor = this.ToCieXyz(color);
return(this.ToHunterLab(xyzColor));
}
public ColourStop(CieLch colour, float position)
{
Colour = colour;
Position = position;
}
/// <summary>
/// Converts a <see cref="CieLch"/> into a <see cref="CieXyy"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="CieXyy"/></returns>
public CieXyy ToCieXyy(CieLch color)
{
var xyzColor = this.ToCieXyz(color);
return(this.ToCieXyy(xyzColor));
}
/// <summary>
/// Converts a <see cref="CieLch"/> into a <see cref="CieLchuv"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="CieLchuv"/></returns>
public CieLchuv ToCieLchuv(CieLch color)
{
CieXyz xyzColor = this.ToCieXyz(color);
return(this.ToCieLchuv(xyzColor));
}
/// <summary>
/// Converts a <see cref="CieLch"/> into a <see cref="YCbCr"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="YCbCr"/></returns>
public YCbCr ToYCbCr(CieLch color)
{
var xyzColor = this.ToCieXyz(color);
return(this.ToYCbCr(xyzColor));
}
/// <summary>
/// Converts a <see cref="CieLch"/> into a <see cref="Hsl"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="Hsl"/></returns>
public Hsl ToHsl(CieLch color)
{
var xyzColor = this.ToCieXyz(color);
return(this.ToHsl(xyzColor));
}
