protected static double ComputeKa(XYZColor whitePoint)
{
if (whitePoint == null) throw new ArgumentNullException("whitePoint");
if (whitePoint == Illuminants.C)
return 175;
double Ka = 100 * (175 / 198.04) * (whitePoint.X + whitePoint.Y);
return Ka;
}
protected static double ComputeKb(XYZColor whitePoint)
{
if (whitePoint == null) throw new ArgumentNullException("whitePoint");
if (whitePoint == Illuminants.C)
return 70;
double Ka = 100 * (70 / 218.11) * (whitePoint.Y + whitePoint.Z);
return Ka;
}
/// <summary>
/// Performs chromatic adaptation of given XYZ color.
/// Target white point is <see cref="WhitePoint"/>.
/// </summary>
public XYZColor Adapt(XYZColor color, XYZColor sourceWhitePoint)
{
if (color == null) throw new ArgumentNullException("color");
if (sourceWhitePoint == null) throw new ArgumentNullException("sourceWhitePoint");
if (!IsChromaticAdaptationPerformed)
throw new InvalidOperationException("Cannot perform chromatic adaptation, provide chromatic adaptation method and white point.");
XYZColor result = ChromaticAdaptation.Transform(color, sourceWhitePoint, WhitePoint);
return result;
}
public LMSColor ToLMS(xyYColor color)
{
if (color == null)
{
throw new ArgumentNullException("color");
}
XYZColor xyzColor = ToXYZ(color);
LMSColor result = ToLMS(xyzColor);
return(result);
}
public LChuvColor ToLChuv(XYZColor color)
{
if (color == null)
{
throw new ArgumentNullException("color");
}
LuvColor luvColor = ToLuv(color);
LChuvColor result = ToLChuv(luvColor);
return(result);
}
public LabColor ToLab(LinearRGBColor color)
{
if (color == null)
{
throw new ArgumentNullException("color");
}
XYZColor xyzColor = ToXYZ(color);
LabColor result = ToLab(xyzColor);
return(result);
}
public void XyzToRgb()
{
var inputXyz = new XYZColor(0.3769, 0.2108, 0.0694);
var rgbWorkingSpace = RGBWorkingSpaces.sRGB;
var xyzToRgb = new ConverterBuilder().FromXYZ(rgbWorkingSpace.WhitePoint).ToRGB(rgbWorkingSpace).Build();
var outputRgb = xyzToRgb.Convert(inputXyz); // RGB [R=0.94, G=0.2, B=0.25]
Assert.Equal(0.9370360111592494, outputRgb.R);
Assert.Equal(0.19976214977119267, outputRgb.G);
Assert.Equal(0.2511427538450153, outputRgb.B);
}
public RGBColor ToRGB(LChuvColor color)
{
if (color == null)
{
throw new ArgumentNullException("color");
}
XYZColor xyzColor = ToXYZ(color);
RGBColor result = ToRGB(xyzColor);
return(result);
}
public LuvColor ToLuv(LChabColor color)
{
if (color == null)
{
throw new ArgumentNullException("color");
}
XYZColor xyzColor = ToXYZ(color);
LuvColor result = ToLuv(xyzColor);
return(result);
}
public LChabColor ToLChab(XYZColor color)
{
if (color == null)
{
throw new ArgumentNullException("color");
}
LabColor labColor = ToLab(color);
LChabColor result = ToLChab(labColor);
return(result);
}
public HunterLabColor ToHunterLab(LChabColor color)
{
if (color == null)
{
throw new ArgumentNullException("color");
}
XYZColor xyzColor = ToXYZ(color);
HunterLabColor result = ToHunterLab(xyzColor);
return(result);
}
public xyYColor ToxyY(XYZColor color)
{
if (color == null)
{
throw new ArgumentNullException("color");
}
// conversion
var converter = new xyYAndXYZConverter();
var result = converter.Convert(color);
return(result);
}
public override void writeTile(int x, int y, int w, int h, Color[] color, float[] alpha)
{
for (int j = 0, index = 0, pixel = 3 * (x + y * width); j < h; j++, pixel += 3 * (width - w))
{
for (int i = 0; i < w; i++, index++, pixel += 3)
{
XYZColor c = Color.NATIVE_SPACE.convertRGBtoXYZ(color[index]);
xyz[pixel + 0] = c.getX();
xyz[pixel + 1] = c.getY();
xyz[pixel + 2] = c.getZ();
}
}
}
public XYZColor ToXYZ(LMSColor color)
{
if (color == null)
{
throw new ArgumentNullException("color");
}
// conversion
var converter = _cachedXYZAndLMSConverter;
XYZColor converted = converter.Convert(color);
return(converted);
}
public LMSColor ToLMS(XYZColor color)
{
if (color == null)
{
throw new ArgumentNullException("color");
}
// conversion
var converter = _cachedXYZAndLMSConverter;
var result = converter.Convert(color);
return(result);
}
public XYZColor ToXYZ(xyYColor color)
{
if (color == null)
{
throw new ArgumentNullException("color");
}
// conversion
var converter = new xyYAndXYZConverter();
XYZColor converted = converter.Convert(color);
return(converted);
}
public void Convert_XYZ_to_xyY(double xyzX, double xyzY, double xyzZ, double x, double y, double Y)
{
// arrange
var input = new XYZColor(xyzX, xyzY, xyzZ);
var converter = new ColourfulConverter();
// act
xyYColor output = converter.ToxyY(input);
// assert
Assert.That(output.x, Is.EqualTo(x).Using(DoubleComparer));
Assert.That(output.y, Is.EqualTo(y).Using(DoubleComparer));
Assert.That(output.Luminance, Is.EqualTo(Y).Using(DoubleComparer));
}
public void Convert_xyY_to_XYZ(double xyzX, double xyzY, double xyzZ, double x, double y, double Y)
{
// arrange
var input = new xyYColor(x, y, Y);
var converter = new ColourfulConverter();
// act
XYZColor output = converter.ToXYZ(input);
// assert
Assert.That(output.X, Is.EqualTo(xyzX).Using(DoubleComparer));
Assert.That(output.Y, Is.EqualTo(xyzY).Using(DoubleComparer));
Assert.That(output.Z, Is.EqualTo(xyzZ).Using(DoubleComparer));
}
public void Convert_XYZ_to_Lab(double x, double y, double z, double l, double a, double b)
{
// arrange
var input = new XYZColor(x, y, z);
var converter = new ColourfulConverter { WhitePoint = Illuminants.D65, TargetLabWhitePoint = Illuminants.D65 };
// act
LabColor output = converter.ToLab(input);
// assert
Assert.That(output.L, Is.EqualTo(l).Using(DoubleComparerLabPrecision));
Assert.That(output.a, Is.EqualTo(a).Using(DoubleComparerLabPrecision));
Assert.That(output.b, Is.EqualTo(b).Using(DoubleComparerLabPrecision));
}
public void Convert_XYZ_to_Luv(double x, double y, double z, double l, double u, double v)
{
// arrange
var input = new XYZColor(x, y, z);
var converter = new ColourfulConverter { WhitePoint = Illuminants.D65, TargetLuvWhitePoint = Illuminants.D65 };
// act
LuvColor output = converter.ToLuv(input);
// assert
Assert.That(output.L, Is.EqualTo(l).Using(DoubleComparerLuvPrecision));
Assert.That(output.u, Is.EqualTo(u).Using(DoubleComparerLuvPrecision));
Assert.That(output.v, Is.EqualTo(v).Using(DoubleComparerLuvPrecision));
}
public void Convert_XYZ_to_xyY(double xyzX, double xyzY, double xyzZ, double x, double y, double Y)
{
// arrange
var input = new XYZColor(xyzX, xyzY, xyzZ);
var converter = new ColourfulConverter();
// act
var output = converter.ToxyY(input);
// assert
Assert.Equal(output.x, x, DoubleComparer);
Assert.Equal(output.y, y, DoubleComparer);
Assert.Equal(output.Luminance, Y, DoubleComparer);
}
public void Samples()
{
// red
var c1 = new XYZColor(0.3769, 0.2108, 0.0694);
// white (relative to D65)
var c2 = new XYZColor(0.95047, 1, 1.08883);
// gray (relative to D65)
var c3 = new XYZColor(0.2034, 0.2140, 0.2331);
// black (relative to D65)
var c4 = new XYZColor(0, 0, 0);
}
public void Convert_XYZ_to_xyY(double xyzX, double xyzY, double xyzZ, double x, double y, double Y)
{
// arrange
var input = new XYZColor(xyzX, xyzY, xyzZ);
var converter = new ColourfulConverter();
// act
xyYColor output = converter.ToxyY(input);
// assert
Assert.That(output.x, Is.EqualTo(x).Using(DoubleComparer));
Assert.That(output.y, Is.EqualTo(y).Using(DoubleComparer));
Assert.That(output.Luminance, Is.EqualTo(Y).Using(DoubleComparer));
}
public RGBColor ToRGB(XYZColor color)
{
if (color == null)
{
throw new ArgumentNullException("color");
}
// conversion
var linear = ToLinearRGB(color);
// companding to RGB
RGBColor result = ToRGB(linear);
return(result);
}
public override void Update(GameTime gt)
{
base.Update(gt);
foreach (var tile in GetTiles())
{
//Convert color to HSV, increase huek
HSVColor hsv = ColorMath.RGBtoHSV(tile.Color);
hsv.H += HUEINCREASE;
XYZColor xyz = ColorMath.RGBtoXYZ(hsv.ToRGBColor());
tile.Color = ColorMath.XYZtoRGB(xyz);
tile.Color.Action = ColorOutOfBoundsAction.WrapAround;
}
}
public void Convert_XYZ_as_vector_to_XYZ(double x, double y, double z)
{
// arrange
IColorVector input = new XYZColor(x, y, z);
var converter = new ColourfulConverter();
// act
XYZColor output = converter.ToXYZ(input);
// assert
Assert.That(output.X, Is.EqualTo(x).Using(DoubleComparer));
Assert.That(output.Y, Is.EqualTo(y).Using(DoubleComparer));
Assert.That(output.Z, Is.EqualTo(z).Using(DoubleComparer));
}
public void Convert_XYZ_as_vector_to_XYZ(double x, double y, double z)
{
// arrange
IColorVector input = new XYZColor(x, y, z);
var converter = new ColourfulConverter();
// act
var output = converter.ToXYZ(input);
// assert
Assert.Equal(output.X, x, DoubleComparer);
Assert.Equal(output.Y, y, DoubleComparer);
Assert.Equal(output.Z, z, DoubleComparer);
}
protected static double ComputeKa(XYZColor whitePoint)
{
if (whitePoint == null)
{
throw new ArgumentNullException("whitePoint");
}
if (whitePoint == Illuminants.C)
{
return(175);
}
double Ka = 100 * (175 / 198.04) * (whitePoint.X + whitePoint.Y);
return(Ka);
}
protected static double ComputeKb(XYZColor whitePoint)
{
if (whitePoint == null)
{
throw new ArgumentNullException("whitePoint");
}
if (whitePoint == Illuminants.C)
{
return(70);
}
double Ka = 100 * (70 / 218.11) * (whitePoint.Y + whitePoint.Z);
return(Ka);
}
public void Convert_sRGB_to_XYZ_D65(double r, double g, double b, double x, double y, double z)
{
// arrange
var input = new RGBColor(r, g, b);
var converter = new ColourfulConverter {
WhitePoint = Illuminants.D65
};
// act
XYZColor output = converter.ToXYZ(input);
// assert
Assert.That(output.X, Is.EqualTo(x).Using(DoubleComparer));
Assert.That(output.Y, Is.EqualTo(y).Using(DoubleComparer));
Assert.That(output.Z, Is.EqualTo(z).Using(DoubleComparer));
}
public void Convert_XYZ_to_Luv(double x, double y, double z, double l, double u, double v)
{
// arrange
var input = new XYZColor(x, y, z);
var converter = new ColourfulConverter {
WhitePoint = Illuminants.D65, TargetLuvWhitePoint = Illuminants.D65
};
// act
LuvColor output = converter.ToLuv(input);
// assert
Assert.That(output.L, Is.EqualTo(l).Using(DoubleComparerLuvPrecision));
Assert.That(output.u, Is.EqualTo(u).Using(DoubleComparerLuvPrecision));
Assert.That(output.v, Is.EqualTo(v).Using(DoubleComparerLuvPrecision));
}
public void Convert_Lab_to_XYZ(double l, double a, double b, double x, double y, double z)
{
// arrange
var input = new LabColor(l, a, b, Illuminants.D65);
var converter = new ColourfulConverter {
WhitePoint = Illuminants.D65, TargetLabWhitePoint = Illuminants.D65
};
// act
XYZColor output = converter.ToXYZ(input);
// assert
Assert.That(output.X, Is.EqualTo(x).Using(DoubleComparerXYZPrecision));
Assert.That(output.Y, Is.EqualTo(y).Using(DoubleComparerXYZPrecision));
Assert.That(output.Z, Is.EqualTo(z).Using(DoubleComparerXYZPrecision));
}
public void Convert_XYZ_to_Lab(double x, double y, double z, double l, double a, double b)
{
// arrange
var input = new XYZColor(x, y, z);
var converter = new ColourfulConverter {
WhitePoint = Illuminants.D65, TargetLabWhitePoint = Illuminants.D65
};
// act
LabColor output = converter.ToLab(input);
// assert
Assert.That(output.L, Is.EqualTo(l).Using(DoubleComparerLabPrecision));
Assert.That(output.a, Is.EqualTo(a).Using(DoubleComparerLabPrecision));
Assert.That(output.b, Is.EqualTo(b).Using(DoubleComparerLabPrecision));
}
public void Convert_XYZ_to_Lab(double x, double y, double z, double l, double a, double b)
{
// arrange
var input = new XYZColor(x, y, z);
var converter = new ColourfulConverter {
WhitePoint = Illuminants.D65, TargetLabWhitePoint = Illuminants.D65
};
// act
var output = converter.ToLab(input);
// assert
Assert.Equal(output.L, l, DoubleComparerLabPrecision);
Assert.Equal(output.a, a, DoubleComparerLabPrecision);
Assert.Equal(output.b, b, DoubleComparerLabPrecision);
}
public void Convert_XYZ_to_Luv(double x, double y, double z, double l, double u, double v)
{
// arrange
var input = new XYZColor(x, y, z);
var converter = new ColourfulConverter {
WhitePoint = Illuminants.D65, TargetLuvWhitePoint = Illuminants.D65
};
// act
var output = converter.ToLuv(input);
// assert
Assert.Equal(output.L, l, DoubleComparerLuvPrecision);
Assert.Equal(output.u, u, DoubleComparerLuvPrecision);
Assert.Equal(output.v, v, DoubleComparerLuvPrecision);
}
public XYZColor ToXYZ(LChuvColor color)
{
if (color == null)
{
throw new ArgumentNullException("color");
}
// conversion to Luv
var luvConverter = new LChuvToLuvConverter();
LuvColor labColor = luvConverter.Convert(color);
// conversion to XYZ (incl. adaptation)
XYZColor result = ToXYZ(labColor);
return(result);
}
public void Convert_XYZ_D65_to_sRGB(double x, double y, double z, double r, double g, double b)
{
// arange
var input = new XYZColor(x, y, z);
var converter = new ColourfulConverter { WhitePoint = Illuminants.D65, TargetRGBWorkingSpace = RGBWorkingSpaces.sRGB };
// act
RGBColor output = converter.ToRGB(input);
// assert
Assert.That(output.WorkingSpace, Is.EqualTo(RGBColor.DefaultWorkingSpace));
Assert.That(output.R, Is.EqualTo(r).Using(DoubleComparer));
Assert.That(output.G, Is.EqualTo(g).Using(DoubleComparer));
Assert.That(output.B, Is.EqualTo(b).Using(DoubleComparer));
}
/// <summary>
/// Convert directly from xyY to RGB
/// </summary>
public static float[] xyYtoRGB(xyYColor xyY)
{
float Yony = xyY.Y / xyY.y;
XYZColor XYZ = new XYZColor(xyY.x * Yony, xyY.Y, (1.0f - xyY.x - xyY.y) * Yony);
float[] XYZf3 = XYZ.AsFloat3;
float[] ret = new float[3];
for (int i=0; i<3; i++) {
ret[i] = 0f;
for (int j=0; j<3; j++)
ret[i] += XYZf3[j] * XYZtoRGBconv[i, j];
}
return new float[]{ret[0], ret[1], ret[2], 1.0f};
}
public void Convert_XYZ_as_vector_to_XYZ(double x, double y, double z)
{
// arrange
IColorVector input = new XYZColor(x, y, z);
var converter = new ColourfulConverter();
// act
XYZColor output = converter.ToXYZ(input);
// assert
Assert.That(output.X, Is.EqualTo(x).Using(DoubleComparer));
Assert.That(output.Y, Is.EqualTo(y).Using(DoubleComparer));
Assert.That(output.Z, Is.EqualTo(z).Using(DoubleComparer));
}
public void XYZColor()
{
var color = new XYZColor(0, 0.5, 0.445);
Assert.AreEqual("XYZ [X=0, Y=0.5, Z=0.45]", color.ToString());
}
public RGBWorkingSpace(XYZColor referenceWhite, ICompanding companding, RGBPrimariesChromaticityCoordinates chromaticityCoordinates)
{
WhitePoint = referenceWhite;
Companding = companding;
ChromaticityCoordinates = chromaticityCoordinates;
}
public void Adapt_XYZ_D65_To_D50_XYZScaling(double x1, double y1, double z1, double x2, double y2, double z2)
{
// arrange
var input = new XYZColor(x1, y1, z1);
var expectedOutput = new XYZColor(x2, y2, z2);
var converter = new ColourfulConverter
{
ChromaticAdaptation = new VonKriesChromaticAdaptation(LMSTransformationMatrix.XYZScaling),
WhitePoint = Illuminants.D50
};
// action
XYZColor output = converter.Adapt(input, Illuminants.D65);
// assert
Assert.That(output.X, Is.EqualTo(expectedOutput.X).Using(DoubleRoundingComparer));
Assert.That(output.Y, Is.EqualTo(expectedOutput.Y).Using(DoubleRoundingComparer));
Assert.That(output.Z, Is.EqualTo(expectedOutput.Z).Using(DoubleRoundingComparer));
}
public void Adapt_XYZ_D65_To_D50_Bradford(double x1, double y1, double z1, double x2, double y2, double z2)
{
// arrange
var input = new XYZColor(x1, y1, z1);
var expectedOutput = new XYZColor(x2, y2, z2);
var converter = new ColourfulConverter
{
WhitePoint = Illuminants.D50
};
// action
XYZColor output = converter.Adapt(input, Illuminants.D65);
// assert
Assert.That(output.X, Is.EqualTo(expectedOutput.X).Using(DoubleRoundingComparer));
Assert.That(output.Y, Is.EqualTo(expectedOutput.Y).Using(DoubleRoundingComparer));
Assert.That(output.Z, Is.EqualTo(expectedOutput.Z).Using(DoubleRoundingComparer));
}
/// <summary>
/// Transforms XYZ color to destination reference white.
/// </summary>
public XYZColor Transform(XYZColor sourceColor, XYZColor sourceWhitePoint, XYZColor targetWhitePoint)
{
if (sourceColor == null) throw new ArgumentNullException("sourceColor");
if (sourceWhitePoint == null) throw new ArgumentNullException("sourceWhitePoint");
if (targetWhitePoint == null) throw new ArgumentNullException("targetWhitePoint");
if (sourceWhitePoint.Equals(targetWhitePoint))
return sourceColor;
LMSColor sourceColorLMS = _conversionToLMS.Convert(sourceColor);
LMSColor sourceWhitePointLMS = _conversionToLMS.Convert(sourceWhitePoint);
LMSColor targetWhitePointLMS = _conversionToLMS.Convert(targetWhitePoint);
Matrix diagonalMatrix = MatrixFactory.CreateDiagonal(targetWhitePointLMS.L / sourceWhitePointLMS.L, targetWhitePointLMS.M / sourceWhitePointLMS.M, targetWhitePointLMS.S / sourceWhitePointLMS.S);
var targetColorLMS = new LMSColor(diagonalMatrix.MultiplyBy(sourceColorLMS.Vector));
XYZColor targetColor = _conversionToXYZ.Convert(targetColorLMS);
return targetColor;
}
