public void Convert_CieXyz_to_Lms(float x, float y, float z, float l, float m, float s)
{
// Arrange
var input = new CieXyz(x, y, z);
var converter = new ColorSpaceConverter();
var expected = new Lms(l, m, s);
Span <CieXyz> inputSpan = new CieXyz[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);
}
}
public void Convert_Lms_to_CieXyy(float l, float m, float s, float x, float y, float yl)
{
// Arrange
var input = new Lms(l, m, s);
var expected = new CieXyy(x, y, yl);
Span <Lms> inputSpan = new Lms[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_Lms_to_CieLuv(float l2, float m, float s, float l, float u, float v)
{
// Arrange
var input = new Lms(l2, m, s);
var expected = new CieLuv(l, u, v);
Span <Lms> inputSpan = new Lms[5];
inputSpan.Fill(input);
Span <CieLuv> actualSpan = new CieLuv[5];
// Act
var actual = Converter.ToCieLuv(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_CieLab_to_Lms(float l, float a, float b, float l2, float m, float s)
{
// Arrange
var input = new CieLab(l, a, b);
var expected = new Lms(l2, m, s);
Span <CieLab> inputSpan = new CieLab[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="Lms"/> into a <see cref="CieXyz"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="CieXyz"/></returns>
public CieXyz ToCieXyz(Lms color)
{
Guard.NotNull(color, nameof(color));
// Conversion
return(this.cachedCieXyzAndLmsConverter.Convert(color));
}
public async Task TestReconnectServerGone(string uri)
{
var factory = Constants.NngFactory;
using var client = Lms.CreateClient(factory, uri);
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(2));
await Task.WhenAll(
Task.Run(async() =>
{
while (!cts.IsCancellationRequested)
{
using var ctsServer = CancellationTokenSource.CreateLinkedTokenSource(cts.Token);
ctsServer.CancelAfter(TimeSpan.FromMilliseconds(200));
using var server = Lms.CreateServerBuilder()
.AddFunction("Foo", (a, b) => default(ValueTask <byte[]>))
.Build(factory, uri);
try {
await server.Listen(1, ctsServer.Token);
}catch (OperationCanceledException) {}
}
}, cts.Token),
Task.Run(async() => {
while (!cts.IsCancellationRequested)
{
try {
await client.Request("Foo", null, cts.Token);
}catch (OperationCanceledException) {}
}
}, cts.Token)
);
}
/// <summary>
/// Converts a <see cref="Lms"/> into a <see cref="YCbCr"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="YCbCr"/></returns>
public YCbCr ToYCbCr(Lms color)
{
Guard.NotNull(color, nameof(color));
var xyzColor = this.ToCieXyz(color);
return(this.ToYCbCr(xyzColor));
}
/// <summary>
/// Converts a <see cref="Lms"/> into a <see cref="Cmyk"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="Cmyk"/></returns>
public Cmyk ToCmyk(Lms color)
{
Guard.NotNull(color, nameof(color));
var xyzColor = this.ToCieXyz(color);
return(this.ToCmyk(xyzColor));
}
/// <summary>
/// Converts a <see cref="Lms"/> into a <see cref="Hsl"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="Hsl"/></returns>
public Hsl ToHsl(Lms color)
{
Guard.NotNull(color, nameof(color));
var xyzColor = this.ToCieXyz(color);
return(this.ToHsl(xyzColor));
}
/// <summary>
/// Converts a <see cref="Lms"/> into a <see cref="LinearRgb"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="LinearRgb"/></returns>
public LinearRgb ToLinearRgb(Lms color)
{
Guard.NotNull(color, nameof(color));
var xyzColor = this.ToCieXyz(color);
return(this.ToLinearRgb(xyzColor));
}
/// <summary>
/// Converts a <see cref="Lms"/> into a <see cref="CieLchuv"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="CieLchuv"/></returns>
public CieLchuv ToCieLchuv(Lms color)
{
Guard.NotNull(color, nameof(color));
CieXyz xyzColor = this.ToCieXyz(color);
return(this.ToCieLchuv(xyzColor));
}
/// <summary>
/// Converts a <see cref="Lms"/> into a <see cref="HunterLab"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="HunterLab"/></returns>
public HunterLab ToHunterLab(Lms color)
{
Guard.NotNull(color, nameof(color));
var xyzColor = this.ToCieXyz(color);
return(this.ToHunterLab(xyzColor));
}
public void LmsConstructorAssignsFields()
{
const float l = 75F;
const float m = -64F;
const float s = 87F;
var lms = new Lms(l, m, s);
Assert.Equal(l, lms.L);
Assert.Equal(m, lms.M);
Assert.Equal(s, lms.S);
}
public void Convert_Lms_to_CieXyz(float l, float m, float s, float x, float y, float z)
{
// Arrange
Lms input = new Lms(l, m, s);
ColorSpaceConverter converter = new ColorSpaceConverter();
// 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 void Convert_CieXyz_to_Lms(float x, float y, float z, float l, float m, float s)
{
// Arrange
CieXyz input = new CieXyz(x, y, z);
ColorSpaceConverter converter = new ColorSpaceConverter();
// Act
Lms output = converter.ToLms(input);
// Assert
Assert.Equal(l, output.L, FloatRoundingComparer);
Assert.Equal(m, output.M, FloatRoundingComparer);
Assert.Equal(s, output.S, FloatRoundingComparer);
}
public void LmsEquality()
{
var x = default(Lms);
var y = new Lms(Vector3.One);
Assert.True(default(Lms) == default(Lms));
Assert.True(new Lms(1, 0, 1) != default(Lms));
Assert.False(new Lms(1, 0, 1) == default(Lms));
Assert.Equal(default(Lms), default(Lms));
Assert.Equal(new Lms(1, 0, 1), new Lms(1, 0, 1));
Assert.Equal(new Lms(Vector3.One), new Lms(Vector3.One));
Assert.False(x.Equals(y));
Assert.False(x.Equals((object)y));
Assert.False(x.GetHashCode().Equals(y.GetHashCode()));
}
/// <inheritdoc/>
public CieXyz Transform(CieXyz sourceColor, CieXyz sourceWhitePoint, CieXyz targetWhitePoint)
{
if (sourceWhitePoint.Equals(targetWhitePoint))
{
return(sourceColor);
}
Lms sourceColorLms = this.converter.Convert(sourceColor);
Lms sourceWhitePointLms = this.converter.Convert(sourceWhitePoint);
Lms targetWhitePointLms = this.converter.Convert(targetWhitePoint);
var vector = new Vector3(targetWhitePointLms.L / sourceWhitePointLms.L, targetWhitePointLms.M / sourceWhitePointLms.M, targetWhitePointLms.S / sourceWhitePointLms.S);
var targetColorLms = new Lms(Vector3.Multiply(vector, sourceColorLms.Vector));
return(this.converter.Convert(targetColorLms));
}
static async Task Main(string[] args)
{
var uri = "ipc://tester";
var path = Path.GetDirectoryName(typeof(Program).Assembly.Location);
var ctx = new NngLoadContext(path);
var factory = NngLoadContext.Init(ctx);
using var cts = new CancellationTokenSource(8000);
await Task.WhenAll(
// Set up server interface
Task.Run(async() => {
await using var server =
Lms.CreateServerBuilder()
.AddFunction <int, int>("Tester", Tester)
.AddFunction <int, int>("ThrowException", ThrowException)
.Build(factory, uri, null, loggerFactory.CreateLogger <IServer>());
await server.Listen(8, cts.Token);
}),
// Client Tester request loop
Task.Run(async() => {
await using var client = Lms.CreateClient(factory, uri, null, loggerFactory.CreateLogger <IClient>());
var random = new Random();
while (!cts.Token.IsCancellationRequested)
{
var request = random.Next();
var result = await client.Request <int, int>("Tester", request, cts.Token);
logger.LogInformation("Requested {Request} and got {Result}", request, result);
}
}),
// Client Tester request loop
Task.Run(async() => {
await using var client = Lms.CreateClient(factory, uri, null, loggerFactory.CreateLogger <IClient>());
while (!cts.Token.IsCancellationRequested)
{
try {
var result = await client.Request <int, int>("ThrowException", 20, cts.Token);
}catch (Exception e) {
logger.LogInformation("Called ThrowException and got a {Type} saying {Message}\n{StackTrace}", e.GetType(), e.Message, e.StackTrace);
}
}
})
);
}
public async Task TestProtocols(string uri)
{
var factory = Constants.NngFactory;
using var server = Lms.CreateServerBuilder()
.AddFunction("Foo", (a, b) => default(ValueTask <byte[]>))
.Build(factory, uri);
using var client = Lms.CreateClient(factory, uri);
using var cts = new CancellationTokenSource();
Task listenTask = null;
try {
listenTask = server.Listen(1, cts.Token);
await client.Request("Foo", null);
}finally{
cts.Cancel();
await listenTask;
}
}
public async Task TestLargeObject(string uri)
{
var factory = Constants.NngFactory;
using var server = Lms.CreateServerBuilder()
.AddFunction <int>("Foo", LargeObject)
.Build(factory, uri);
using var client = Lms.CreateClient(factory, uri);
using var cts = new CancellationTokenSource();
Task listenTask = null;
try {
listenTask = server.Listen(1, cts.Token);
var r = new Random();
var s = 1024 * 1024 * 2 + r.Next(12, 345);
var b = await client.Request("Foo", s);
Assert.Equal(s, b.Length);
}finally{
cts.Cancel();
await listenTask;
}
}
public async Task TestRemoteException(string uri)
{
var factory = Constants.NngFactory;
using var server = Lms.CreateServerBuilder()
.AddFunction <string>("Throw", ThrowException)
.Build(factory, uri);
using var client = Lms.CreateClient(factory, uri);
using var cts = new CancellationTokenSource();
Task listenTask = null;
try {
listenTask = server.Listen(1, cts.Token);
var exception = await Assert.ThrowsAsync <RemoteException>(async() => await client.Request("Throw", "Foo Bar"));
Assert.Equal("lms.test", exception.Source);
Assert.Equal("Foo Bar", exception.Message);
Assert.Contains($"at {typeof(ExceptionTests).FullName}.{nameof(ThrowException)}(String message, CancellationToken cancellationToken)", exception.StackTrace);
}finally{
cts.Cancel();
await listenTask;
}
}
/// <summary>
/// Converts a <see cref="Lms"/> into a <see cref="CieXyz"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="CieXyz"/></returns>
public CieXyz ToCieXyz(Lms color)
{
// Conversion
return(this.cachedCieXyzAndLmsConverter.Convert(color));
}
/// <summary>
/// Converts a <see cref="Lms"/> into a <see cref="Cmyk"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="Cmyk"/></returns>
public Cmyk ToCmyk(Lms color)
{
var xyzColor = this.ToCieXyz(color);
return(this.ToCmyk(xyzColor));
}
/// <summary>
/// Converts a <see cref="Lms"/> into a <see cref="HunterLab"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="HunterLab"/></returns>
public HunterLab ToHunterLab(Lms color)
{
var xyzColor = this.ToCieXyz(color);
return(this.ToHunterLab(xyzColor));
}
/// <summary>
/// Converts a <see cref="Lms"/> into a <see cref="CieXyy"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="CieXyy"/></returns>
public CieXyy ToCieXyy(Lms color)
{
var xyzColor = this.ToCieXyz(color);
return(this.ToCieXyy(xyzColor));
}
/// <summary>
/// Converts a <see cref="Lms"/> into a <see cref="Hsl"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="Hsl"/></returns>
public Hsl ToHsl(Lms color)
{
var xyzColor = this.ToCieXyz(color);
return(this.ToHsl(xyzColor));
}
/// <summary>
/// Converts a <see cref="Lms"/> into a <see cref="CieLab"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="CieLab"/></returns>
public CieLab ToCieLab(Lms color)
{
CieXyz xyzColor = this.ToCieXyz(color);
return(this.ToCieLab(xyzColor));
}
/// <summary>
/// Converts a <see cref="Lms"/> into a <see cref="YCbCr"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="YCbCr"/></returns>
public YCbCr ToYCbCr(Lms color)
{
var xyzColor = this.ToCieXyz(color);
return(this.ToYCbCr(xyzColor));
}
/// <summary>
/// Converts a <see cref="Lms"/> into a <see cref="LinearRgb"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="LinearRgb"/></returns>
public LinearRgb ToLinearRgb(Lms color)
{
var xyzColor = this.ToCieXyz(color);
return(this.ToLinearRgb(xyzColor));
}
/// <summary>
/// Converts a <see cref="Lms"/> into a <see cref="CieLch"/>
/// </summary>
/// <param name="color">The color to convert.</param>
/// <returns>The <see cref="CieLch"/></returns>
public CieLch ToCieLch(Lms color)
{
CieXyz xyzColor = this.ToCieXyz(color);
return(this.ToCieLch(xyzColor));
}
