public void FromGrayCtor()
{
var first = new LinearRGBColor(r: .4, g: .4, b: .4);
var second = LinearRGBColor.FromGray(.4);
CustomAssert.EqualsWithHashCode(first, second);
}
public void LinearRGBColor()
{
var first = new LinearRGBColor(0, 0.5, 0.445);
var second = new LinearRGBColor(0, 0.5, 0.445);
Assert.Equal(first, (object)second);
}
public void Clamp()
{
var(r, g, b) = new LinearRGBColor(1.1, -0.5, 0.01).Clamp();
Assert.Equal(1, r);
Assert.Equal(0, g);
Assert.Equal(0.01, b);
}
/// <summary>
/// Adapts linear RGB color from the source working space to working space set in <see cref="TargetRGBWorkingSpace"/>.
/// </summary>
public LinearRGBColor Adapt(LinearRGBColor color)
{
if (color == null)
{
throw new ArgumentNullException("color");
}
if (!IsChromaticAdaptationPerformed)
{
throw new InvalidOperationException("Cannot perform chromatic adaptation, provide chromatic adaptation method and white point.");
}
if (color.WorkingSpace.Equals(TargetRGBWorkingSpace))
{
return(color);
}
// conversion to XYZ
var converterToXYZ = GetLinearRGBToXYZConverter(color.WorkingSpace);
XYZColor unadapted = converterToXYZ.Convert(color);
// adaptation
XYZColor adapted = ChromaticAdaptation.Transform(unadapted, color.WorkingSpace.WhitePoint, TargetRGBWorkingSpace.WhitePoint);
// conversion back to RGB
var converterToRGB = GetXYZToLinearRGBConverter(TargetRGBWorkingSpace);
LinearRGBColor result = converterToRGB.Convert(adapted);
return(result);
}
public void NormalizeIntensity()
{
var(r, g, b) = new LinearRGBColor(1.282323002024544, 0.92870160729369322, 0.55886769485605214).NormalizeIntensity();
Assert.Equal(1, r);
Assert.Equal(0.72423375844264681, g, DoubleComparer);
Assert.Equal(0.4358244326692311, b, DoubleComparer);
}
public void BlendRgbColors()
{
var color1 = RGBColor.FromRGB8Bit(255, 0, 0);
var color2 = RGBColor.FromRGB8Bit(0, 0, 255);
var rgbToLinear = new ConverterBuilder().FromRGB().ToLinearRGB().Build();
var linear1 = rgbToLinear.Convert(color1);
var linear2 = rgbToLinear.Convert(color2);
var linearBlend = new LinearRGBColor(
(linear1.R + linear2.R) / 2,
(linear1.G + linear2.G) / 2,
(linear1.B + linear2.B) / 2);
var linearToRgb = new ConverterBuilder().FromLinearRGB().ToRGB().Build();
var blend = linearToRgb.Convert(linearBlend);
blend.ToRGB8Bit(out var r, out var g, out var b);
Assert.Equal(188, r);
Assert.Equal(0, g);
Assert.Equal(188, b);
}
public void Equals_Different()
{
var first = new LinearRGBColor(r: .2, g: .205, b: .45445);
var second = new LinearRGBColor(r: .1, g: .205, b: .45445);
CustomAssert.NotEqualsWithHashCode(first, second);
}
internal async Task SetLightColor(PhilipsHueLight light, Color newColor)
{
var converter = new Colourful.Conversion.ColourfulConverter {
ChromaticAdaptation = null
};
var linearColor = new LinearRGBColor(newColor.R / 255f, newColor.G / 255f, newColor.B / 255f);
var xyY = converter.ToxyY(linearColor);
var lightStateRequest = new RestRequest(string.Format("{0}/lights/{1}/state", credentials.Username, light.BridgeLocalID), Method.PUT);
lightStateRequest.AddJsonBody(
new {
xy = new List <double>()
{
xyY.x, xyY.y
},
bri = Math.Clamp((int)(xyY.Luminance * 255.0), 1, 254),
//bri = 254,
transitiontime = 1
}
);
var stateSettingResponse = client.Put <HueAPIResponse <IDictionary <string, object> >[]>(lightStateRequest);
// if (stateSettingResponse.error != null) {
// // TODO Better error handling.
// throw new Exception(stateSettingResponse.error.description);
// }
}
public void SetPixel(int x, int y, Vector4 color)
{
var clampedColor = Vector4.Clamp(color, Vector4.Zero, Vector4.One);
var linearRgbColor = new LinearRGBColor(clampedColor.X, clampedColor.Y, clampedColor.Z);
var sRgbColor = _converter.ToRGB(linearRgbColor);
SetPixel(x, y, new MonoColor((float)sRgbColor.R, (float)sRgbColor.G, (float)sRgbColor.B));
}
public void VectorCtor()
{
var first = new LinearRGBColor(r: .2, g: .205, b: .45445);
var vector = new[] { .2, .205, .45445 };
var second = new LinearRGBColor(vector);
CustomAssert.EqualsWithHashCode(first, second);
Assert.Equal(vector, second.Vector);
}
public void Dctor()
{
const double r1 = .1;
const double g1 = .205;
const double b1 = .45445;
var(r2, g2, b2) = new LinearRGBColor(r1, g1, b1);
Assert.Equal(r1, r2);
Assert.Equal(g1, g2);
Assert.Equal(b1, b2);
}
public LinearRGBColor ToLinearRGB(HunterLabColor color)
{
if (color == null)
{
throw new ArgumentNullException("color");
}
XYZColor xyzColor = ToXYZ(color);
LinearRGBColor result = ToLinearRGB(xyzColor);
return(result);
}
public xyYColor ToxyY(LinearRGBColor color)
{
if (color == null)
{
throw new ArgumentNullException("color");
}
XYZColor xyzColor = ToXYZ(color);
xyYColor result = ToxyY(xyzColor);
return(result);
}
} // end ColorConversion
/// <summary>
/// CIELAB color to RGB color 변환
/// </summary>
/// <param name="l">L(luminosity) - 명도축</param>
/// <param name="a">a - 빨강(Red) / 초록(Green) 의 보색(a complementary color)축</param>
/// <param name="b">b - 노랑(Yellow) / 파랑(Blue) 의 보색(a complementary color)축</param>
/// <returns>colorful.net RGBColor 형 반환</returns>
public LinearRGBColor LabToRGB(double l, double a, double b)
{
LabColor input = new LabColor(l, a, b);
var converter = new ColourfulConverter {
WhitePoint = Illuminants.D50
};
LinearRGBColor output = converter.ToLinearRGB(input);
return(output);
}
public LinearRGBColor ToLinearRGB(RGBColor color)
{
if (color == null)
{
throw new ArgumentNullException("color");
}
// conversion
var converter = new RGBToLinearRGBConverter();
LinearRGBColor result = converter.Convert(color);
return(result);
}
public void SamplesLinearRgb()
{
// red
var c1 = new LinearRGBColor(0.863, 0.0331, 0.0513);
// gray
var c4 = new LinearRGBColor(0.5, 0.5, 0.5);
var c5 = LinearRGBColor.FromGray(0.5);
// white
var c6 = new LinearRGBColor(1, 1, 1);
// black
var c7 = new LinearRGBColor(0, 0, 0);
}
public XYZColor ToXYZ(RGBColor color)
{
if (color == null)
{
throw new ArgumentNullException("color");
}
// uncompanding
var rgbConverter = new RGBToLinearRGBConverter();
LinearRGBColor linear = rgbConverter.Convert(color);
// conversion
var result = ToXYZ(linear);
return(result);
}
public XYZColor ToXYZ(LinearRGBColor color)
{
if (color == null)
{
throw new ArgumentNullException("color");
}
// conversion
var converterXyz = GetLinearRGBToXYZConverter(color.WorkingSpace);
XYZColor unadapted = converterXyz.Convert(color);
// adaptation
XYZColor adapted = color.WorkingSpace.WhitePoint.Equals(WhitePoint) || !IsChromaticAdaptationPerformed
? unadapted
: Adapt(unadapted, color.WorkingSpace.WhitePoint);
return(adapted);
}
public LinearRGBColor ToLinearRGB(XYZColor color)
{
if (color == null)
{
throw new ArgumentNullException("color");
}
// adaptation
XYZColor adapted = TargetRGBWorkingSpace.WhitePoint.Equals(WhitePoint) || !IsChromaticAdaptationPerformed
? color
: ChromaticAdaptation.Transform(color, WhitePoint, TargetRGBWorkingSpace.WhitePoint);
// conversion to linear RGB
var xyzConverter = GetXYZToLinearRGBConverter(TargetRGBWorkingSpace);
LinearRGBColor result = xyzConverter.Convert(adapted);
return(result);
}
public LinearRGBColor ToLinearRGB <T>(T color) where T : IColorVector
{
if (color == null)
{
throw new ArgumentNullException("color");
}
LinearRGBColor converted = color as LinearRGBColor;
if (converted != null)
{
return(converted);
}
else
{
dynamic source = color;
return(ToLinearRGB(source));
}
}
public void RangesOfChannelValuesAndClamping()
{
var x1 = (1.25).Clamp(0, 1);
var x2 = (-0.5).Clamp(0, 1);
var x3 = (0.75).Clamp(0, 1);
// asserts
Assert.Equal(1, x1);
Assert.Equal(0, x2);
Assert.Equal(0.75, x3);
var arr1 = new[] { 1.25, -0.5, 0.75 }.Clamp(0, 1);
// asserts
Assert.Equal(new[] { 1, 0, 0.75 }, arr1);
var arr2 = new[] { -50, 75, 1.25 }.Clamp(new double[] { 0, 0, 0 }, new double[] { 100, 100, 1 }); // { 0, 75, 1 }
// asserts
Assert.Equal(new double[] { 0, 75, 1 }, arr2);
var color1 = new RGBColor(2, -3, 0.5);
var color2 = color1.Clamp();
// asserts
Assert.Equal(new[] { 1, 0, 0.5 }, color2.Vector);
var color3 = color1.NormalizeIntensity(); // RGB [R=1, G=0, B=0.25]
// asserts
Assert.Equal(new[] { 1, 0, 0.25 }, color3.Vector);
// linear RGB
var linearColor = new LinearRGBColor(2, -3, 0.5);
var normalizedLinearColor = linearColor.NormalizeIntensity(); // LinearRGB [R=1, G=0, B=0.25]
// asserts
Assert.Equal(new[] { 1, 0, 0.25 }, normalizedLinearColor.Vector);
}
/// <summary>
/// Adapts linear RGB color from the source working space to working space set in <see cref="TargetRGBWorkingSpace"/>.
/// </summary>
public LinearRGBColor Adapt(LinearRGBColor color)
{
if (color == null) throw new ArgumentNullException("color");
if (!IsChromaticAdaptationPerformed)
throw new InvalidOperationException("Cannot perform chromatic adaptation, provide chromatic adaptation method and white point.");
if (color.WorkingSpace.Equals(TargetRGBWorkingSpace))
return color;
// conversion to XYZ
var converterToXYZ = GetLinearRGBToXYZConverter(color.WorkingSpace);
XYZColor unadapted = converterToXYZ.Convert(color);
// adaptation
XYZColor adapted = ChromaticAdaptation.Transform(unadapted, color.WorkingSpace.WhitePoint, TargetRGBWorkingSpace.WhitePoint);
// conversion back to RGB
var converterToRGB = GetXYZToLinearRGBConverter(TargetRGBWorkingSpace);
LinearRGBColor result = converterToRGB.Convert(adapted);
return result;
}
public void ToString_Simple()
{
var color = new LinearRGBColor(r: .1, g: .205, b: .45445);
Assert.Equal("LinearRGB [R=0.1, G=0.21, B=0.45]", color.ToString());
}
