//this is the core of the algorithm. the output image is computed in the HCL color space
//using the gray scale visible image for Luminance and thermal image for Hue
private unsafe void FuseLuminances()
{
var converter = new ColourfulConverter {
WhitePoint = Illuminants.D65
};
var data = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height),
ImageLockMode.WriteOnly, PixelFormat.Format32bppRgb);
int *dst = (int *)data.Scan0;
for (int i = 0; i < visibles.Length; i++)
{
double luminance = visibles[i] * 100; //0..100
double hue = Math.Min(1, thermals[i] * hueGain);
hue = 300 - (int)(hue * 300); //0..300
//compose HCL color
var hclColor = new LChabColor(luminance, chroma, hue);
//convert to RGB and put in bitmap
Color color = converter.ToRGB(hclColor);
* dst++ = (color.R << 16) | (color.G << 8) | color.B;
}
bitmap.UnlockBits(data);
}
public static Vector4 SRGB(float r, float g, float b)
{
var converter = new ColourfulConverter();
var srgb = new RGBColor(r, g, b);
var linear = converter.ToLinearRGB(srgb);
return(new Vector4((float)linear.R, (float)linear.G, (float)linear.B, 0));
}
private static LabColor ToLabColor(Color color)
{
var converter = new ColourfulConverter {
TargetLabWhitePoint = Illuminants.D65
};
return(converter.ToLab(new RGBColor(color.R / 255.0, color.G / 255.0, color.B / 255.0)));
}
/// <summary>
/// Color conversion
/// The ColourfulConverter facade can convert from any of the supported color spaces to any other color space.
/// It always performs the chromatic adaptation if the input and output color space white points are different.
/// </summary>
private void ColorConversion()
{
RGBColor input = new RGBColor(1, 0, 0);
var converter = new ColourfulConverter {
WhitePoint = Illuminants.D50
};
XYZColor output = converter.ToXYZ(input);
} // end ColorConversion
/// <summary>
/// Chromatic adaptation
/// The adaptation can be also performed alone (e.g. from CIELAB D50 to CIELAB D65).
/// </summary>
private void ChromaticAdaptation()
{
LabColor input = new LabColor(10, 20, 30, Illuminants.D50);
var converter = new ColourfulConverter {
TargetLabWhitePoint = Illuminants.D65
};
LabColor output = converter.Adapt(input);
} // end ChromaticAdaptation
public static LabColor Color2Lab(Color color)
{
var converter = new ColourfulConverter {
WhitePoint = Illuminants.D50, TargetRGBWorkingSpace = RGBWorkingSpaces.sRGB
};
RGBColor rgbColor = new RGBColor(color.r, color.g, color.b);
LabColor output = converter.ToLab(rgbColor);
return(output);
}
} // 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 ColorCheckerCalculatorTest()
{
TestData = ColorCheckerCalculatorData.GetData().ToArray();
_converter = new ColourfulConverter
{
WhitePoint = Illuminants.C,
TargetRGBWorkingSpace = RGBWorkingSpaces.sRGB,
TargetLabWhitePoint = Illuminants.C,
TargetLuvWhitePoint = Illuminants.C,
ChromaticAdaptation = new VonKriesChromaticAdaptation()
};
}
internal static PixelFarm.TempContext <ColourfulConverter> BorrowColourfulConverter(
out ColourfulConverter conveter)
{
if (!PixelFarm.Temp <ColourfulConverter> .IsInit())
{
PixelFarm.Temp <ColourfulConverter> .SetNewHandler(
() => new ColourfulConverter(),
p => { });//when relese back
}
return(PixelFarm.Temp <ColourfulConverter> .Borrow(out conveter));
}
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));
}
private bool Compare(Bitmap bitmap, int x, int y, Color color)
{
var difference = new CIE76ColorDifference();
var converter = new ColourfulConverter()
{
WhitePoint = Illuminants.D65
};
var rgbColor = bitmap.GetPixel(bitmap.Width - x, bitmap.Height - y);
var labColor = converter.ToLab(new RGBColor(rgbColor));
var cmpColor = converter.ToLab(new RGBColor(color));
var diff = difference.ComputeDifference(labColor, cmpColor);
return(Math.Abs(diff) < ColorDiffThreashold);
}
public static Color Lab2Color(LabColor color)
{
Color output = new Color();
var converter = new ColourfulConverter {
WhitePoint = Illuminants.D50, TargetRGBWorkingSpace = RGBWorkingSpaces.sRGB
};
RGBColor rgbColor = converter.ToRGB(color);
output.r = (float)rgbColor.R;
output.g = (float)rgbColor.G;
output.b = (float)rgbColor.B;
output.a = 1.0f;
return(output);
}
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
var output = converter.ToXYZ(input);
// assert
Assert.Equal(output.X, xyzX, DoubleComparer);
Assert.Equal(output.Y, xyzY, DoubleComparer);
Assert.Equal(output.Z, xyzZ, DoubleComparer);
}
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 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);
}
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_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_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_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);
}
private Color[] GetNColorsForBarGraph(int n)
{
var converter = new ColourfulConverter();
var start = (L : 65, a : 65, b : -15);
var end = (L : 25, a : -40, b : -35);
var delta = (L : end.L - start.L, a : end.a - start.a, b : end.b - start.b);
var colors = Enumerable.Range(0, n)
.Select(x => (double)x / (n - 1))
.Select(x => (L: start.L + delta.L * x, a: start.a + delta.a * x, b: start.b + delta.b * x))
.Select(x => new LabColor(x.L, x.a, x.b))
.Select(x => converter.ToRGB(x).ToColor())
.Reverse()
.ToArray();
return(colors);
}
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
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 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
var output = converter.ToXYZ(input);
// assert
Assert.Equal(output.X, x, DoubleComparerXYZPrecision);
Assert.Equal(output.Y, y, DoubleComparerXYZPrecision);
Assert.Equal(output.Z, z, DoubleComparerXYZPrecision);
}
public void Convert_sRGB_to_XYZ_D50(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.D50
};
// 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);
}
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));
}
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
var output = converter.ToRGB(input);
// assert
Assert.Equal(output.WorkingSpace, RGBColor.DefaultWorkingSpace);
Assert.Equal(output.R, r, DoubleComparer);
Assert.Equal(output.G, g, DoubleComparer);
Assert.Equal(output.B, b, DoubleComparer);
}
public void Adapt_LChab_D50_To_D65(double l1, double c1, double h1, double l2, double c2, double h2)
{
// arrange
var input = new LChabColor(l1, c1, h1, Illuminants.D50);
var expectedOutput = new LChabColor(l2, c2, h2);
var converter = new ColourfulConverter {
TargetLabWhitePoint = Illuminants.D65
};
// action
LChabColor output = converter.Adapt(input);
// assert
Assert.That(output.L, Is.EqualTo(expectedOutput.L).Using(DoubleRoundingComparer));
Assert.That(output.C, Is.EqualTo(expectedOutput.C).Using(DoubleRoundingComparer));
Assert.That(output.h, Is.EqualTo(expectedOutput.h).Using(DoubleRoundingComparer));
}
public void Adapt_Lab_D65_To_D50(double l1, double a1, double b1, double l2, double a2, double b2)
{
// arrange
var input = new LabColor(l1, a1, b1, Illuminants.D65);
var expectedOutput = new LabColor(l2, a2, b2);
var converter = new ColourfulConverter {
TargetLabWhitePoint = Illuminants.D50
};
// action
LabColor output = converter.Adapt(input);
// assert
Assert.That(output.L, Is.EqualTo(expectedOutput.L).Using(DoublePrecisionComparer));
Assert.That(output.a, Is.EqualTo(expectedOutput.a).Using(DoublePrecisionComparer));
Assert.That(output.b, Is.EqualTo(expectedOutput.b).Using(DoublePrecisionComparer));
}
