///<summary>
/// Converts the specified MagickColor to an instance of this type.
///</summary>
public static ColorMono FromMagickColor(MagickColor color)
{
if (color == null)
return null;
return new ColorMono(color);
}
private static void Test_Pixel_NotEqual(MagickImage image, int x, int y, MagickColor color)
{
using (PixelCollection collection = image.GetReadOnlyPixels())
{
ColorAssert.AreNotEqual(color, collection.GetPixel(x, y));
}
}
ColorYUV(MagickColor color)
: base(color)
{
_Y = (0.29900 * color.R) + (0.58700 * color.G) + (0.11400 * color.B);
_U = (-0.14740 * color.R) - (0.28950 * color.G) + (0.43690 * color.B);
_V = (0.61500 * color.R) - (0.51500 * color.G) - (0.10000 * color.B);
}
public static void AreEqual(MagickColor expected, MagickImage image, int x, int y)
{
using (PixelCollection pixels = image.GetPixels())
{
AreEqual(expected, pixels.GetPixel(x, y));
}
}
public static void AreNotEqual(MagickColor notExpected, MagickImage image, int x, int y)
{
using (PixelCollection collection = image.GetPixels())
{
AreNotEqual(notExpected, collection.GetPixel(x, y));
}
}
private static void TestPixels(MagickImage image, MagickColor firstRow, MagickColor secondRow)
{
using (PixelCollection pixels = image.GetPixels())
{
for (int y = 0; y < 2; y++)
for (int x = 0; x < 10; x++)
ColorAssert.AreEqual(y == 0 ? firstRow : secondRow, pixels.GetPixel(x, y).ToColor());
}
using (MemoryStream memStream = new MemoryStream())
{
image.Format = MagickFormat.Bmp;
image.Write(memStream);
memStream.Position = 0;
using (MagickImage output = new MagickImage(memStream))
{
using (PixelCollection pixels = output.GetPixels())
{
for (int y = 0; y < 2; y++)
for (int x = 0; x < 10; x++)
ColorAssert.AreEqual(y == 0 ? firstRow : secondRow, pixels.GetPixel(x, y).ToColor());
}
}
}
}
public void Test_IComparable()
{
MagickColor first = new MagickColor(MagickColors.White);
Assert.AreEqual(0, first.CompareTo(first));
Assert.AreEqual(1, first.CompareTo(null));
Assert.IsFalse(first < null);
Assert.IsFalse(first <= null);
Assert.IsTrue(first > null);
Assert.IsTrue(first >= null);
Assert.IsTrue(null < first);
Assert.IsTrue(null <= first);
Assert.IsFalse(null > first);
Assert.IsFalse(null >= first);
MagickColor second = new MagickColor(MagickColors.Black);
Assert.AreEqual(1, first.CompareTo(second));
Assert.IsFalse(first < second);
Assert.IsFalse(first <= second);
Assert.IsTrue(first > second);
Assert.IsTrue(first >= second);
second = new MagickColor(MagickColors.White);
Assert.AreEqual(0, first.CompareTo(second));
Assert.IsFalse(first < second);
Assert.IsTrue(first <= second);
Assert.IsFalse(first > second);
Assert.IsTrue(first >= second);
}
/// <summary>
/// Initializes a new instance of the SparseColorArg class.
/// </summary>
/// <param name="x">The X position.</param>
/// <param name="y">The Y position.</param>
/// <param name="color">The color.</param>
public SparseColorArg(double x, double y, MagickColor color)
{
Throw.IfNull("color", color);
X = x;
Y = y;
Color = color;
}
private static void Test_PixelColor(PixelCollection pixels, int x, int y, MagickColor color)
{
var values = pixels.GetValue(x, y);
Assert.AreEqual(3, values.Length);
MagickColor magickColor = new MagickColor(values[0], values[1], values[2]);
ColorAssert.AreEqual(color, magickColor);
}
private ColorHSL(MagickColor color)
: base(color)
{
Tuple<double, double, double> value = Wrapper.MagickColor.ConvertRGBToHSL(MagickColor.GetInstance(color));
Hue = value.Item1;
Saturation = value.Item3;
Luminosity = value.Item2;
}
private static void AreEqual(QuantumType expected, QuantumType actual, MagickColor actualColor, float delta, string channel)
{
#if (Q16HDRI)
if (double.IsNaN(actual))
actual = 0;
#endif
Assert.AreEqual(expected, actual, delta, channel + " is not equal (" + actualColor.ToString() + ")");
}
private void TestColor(string hexValue, float red, float green, float blue, bool isTransparent, double delta)
{
MagickColor color = new MagickColor(hexValue);
Assert.AreEqual(red, color.R, delta);
Assert.AreEqual(green, color.G, delta);
Assert.AreEqual(blue, color.B, delta);
if (isTransparent)
ColorAssert.IsTransparent(color.A);
else
ColorAssert.IsNotTransparent(color.A);
}
public void Test_GetValues()
{
using (MagickImage image = new MagickImage(Color.PowderBlue, 1, 1))
{
using (PixelCollection pixels = image.GetReadOnlyPixels())
{
var values = pixels.GetValues();
Assert.AreEqual(3, values.Length);
MagickColor color = new MagickColor(values[0], values[1], values[2]);
ColorAssert.AreEqual(Color.PowderBlue, color);
}
}
}
private MagickImageInfo CreateMagickImageInfo(MagickColor color, int width, int height)
{
using (MemoryStream memStream = new MemoryStream())
{
using (MagickImage image = new MagickImage(color, width, height))
{
image.Format = MagickFormat.Png;
image.Write(memStream);
memStream.Position = 0;
return new MagickImageInfo(memStream);
}
}
}
public static void AreEqual(MagickColor expected, MagickColor actual)
{
Assert.IsNotNull(actual);
#if (Q16HDRI)
/* Allow difference of 1 due to rounding issues */
QuantumType delta = 1;
#else
QuantumType delta = 0;
#endif
AreEqual(expected.R, actual.R, actual, delta, "R");
AreEqual(expected.G, actual.G, actual, delta, "G");
AreEqual(expected.B, actual.B, actual, delta, "B");
AreEqual(expected.A, actual.A, actual, delta, "A");
}
private static void TestPixels(MagickImage image, MagickColor color)
{
using (MemoryStream memStream = new MemoryStream())
{
image.Format = MagickFormat.Png;
image.Write(memStream);
memStream.Position = 0;
using (MagickImage output = new MagickImage(memStream))
{
using (PixelCollection pixels = image.GetReadOnlyPixels())
{
for (int i = 0; i < 10; i++)
ColorAssert.AreEqual(color, pixels.GetPixel(i, 0).ToColor());
}
}
}
}
public void Test_Transparent()
{
MagickColor transparent = null;
Color transparentColor = transparent;
Assert.AreEqual(Color.Empty, transparentColor);
transparent = MagickColors.Transparent;
ColorAssert.IsTransparent(transparent.A);
ColorAssert.AreEqual(Color.Transparent, transparent);
transparent = new MagickColor("transparent");
ColorAssert.IsTransparent(transparent.A);
ColorAssert.AreEqual(Color.Transparent, transparent);
transparentColor = transparent;
Assert.AreEqual(Color.Transparent.R, transparentColor.R);
Assert.AreEqual(Color.Transparent.G, transparentColor.G);
Assert.AreEqual(Color.Transparent.B, transparentColor.B);
Assert.AreEqual(Color.Transparent.A, transparentColor.A);
}
private ColorHSL(MagickColor color)
: base(color)
{
Initialize(color.R, color.G, color.B);
}
public void Test_GetValue()
{
using (MagickImage image = new MagickImage(MagickColors.Red, 5, 10))
{
using (PixelCollection pixels = image.GetPixels())
{
var values = pixels.GetValue(0, 0);
Assert.AreEqual(3, values.Length);
MagickColor color = new MagickColor(values[0], values[1], values[2]);
ColorAssert.AreEqual(MagickColors.Red, color);
}
}
}
/// <summary> /// Initializes a new instance that implements <see cref="IMagickImage"/>. /// </summary> /// <param name="color">The color to fill the image with.</param> /// <param name="width">The width.</param> /// <param name="height">The height.</param> /// <returns>A new <see cref="IMagickImage"/> instance.</returns> public IMagickImage CreateImage(MagickColor color, int width, int height) => new MagickImage(color, width, height);
private ColorRGB(MagickColor color)
: base(color)
{
}
private void ExecuteDrawableTextUnderColor(XmlElement element, Collection <IDrawable> drawables)
{
MagickColor color_ = GetValue <MagickColor>(element, "color");
drawables.Add(new DrawableTextUnderColor(color_));
}
private static void AreNotEqual(MagickColor expected, Pixel actual)
{
AreNotEqual(expected, actual.ToColor());
}
/// <summary>
/// Adds a new instance of the <see cref="DrawableStrokeColor" /> class to the <see cref="Drawables" />.
/// </summary>
/// <param name="color">The color to use.</param>
/// <returns>The <see cref="Drawables" /> instance.</returns>
public Drawables StrokeColor(MagickColor color)
{
_drawables.Add(new DrawableStrokeColor(color));
return(this);
}
public void StrokeColor(MagickColor color)
{
_NativeInstance.StrokeColor(color);
}
private void ExecuteDrawableStrokeColor(XmlElement element, Collection <IDrawable> drawables)
{
MagickColor color_ = Variables.GetValue <MagickColor>(element, "color");
drawables.Add(new DrawableStrokeColor(color_));
}
/// <summary>
/// Adds a new instance of the <see cref="DrawableFillColor" /> class to the <see cref="Drawables" />.
/// </summary>
/// <param name="color">The color to use.</param>
/// <returns>The <see cref="Drawables" /> instance.</returns>
public Drawables FillColor(MagickColor color)
{
_drawables.Add(new DrawableFillColor(color));
return(this);
}
private ColorMono(MagickColor color)
: base(color)
{
}
public void BorderColor(MagickColor color)
{
_NativeInstance.BorderColor(color);
}
public void TextUnderColor(MagickColor color)
{
_NativeInstance.TextUnderColor(color);
}
///<summary>
/// Creates a new DrawableFillColor instance.
///</summary>
///<param name="color">The color to use.</param>
public DrawableFillColor(MagickColor color)
{
Color = color;
}
/// <summary>
/// Adds a new instance of the <see cref="DrawableTextUnderColor" /> class to the <see cref="Drawables" />.
/// </summary>
/// <param name="color">The color to use.</param>
/// <returns>The <see cref="Drawables" /> instance.</returns>
public Drawables TextUnderColor(MagickColor color)
{
_drawables.Add(new DrawableTextUnderColor(color));
return(this);
}
/// <summary>
/// Initializes a new instance that implements <see cref="IMagickImage"/>.
/// </summary>
/// <param name="color">The color to fill the image with.</param>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
/// <returns>A new <see cref="IMagickImage"/> instance.</returns>
public IMagickImage CreateImage(MagickColor color, int width, int height)
{
return(new MagickImage(color, width, height));
}
private ColorGray(MagickColor color)
: base(color)
{
_Shade = Quantum.Scale(color.R);
}
public void FillColor(MagickColor color) => _nativeInstance.FillColor(color);
///<summary>
/// Creates a new DrawableStrokeColor instance.
///</summary>
///<param name="color">The color to use.</param>
public DrawableStrokeColor(MagickColor color)
{
Throw.IfNull("color", color);
Color = color;
}
/// <summary>
/// Initializes a new instance of the <see cref="ColorBase"/> class.
/// </summary>
/// <param name="color">The color to use.</param>
protected ColorBase(MagickColor color)
{
Color = color;
}
private ColorHSL(MagickColor color)
: base(color)
{
Initialize(color.R, color.G, color.B);
}
private ColorHSL(MagickColor color)
: base(color)
{
Tuple <double, double, double> value = Wrapper.MagickColor.ConvertRGBToHSL(MagickColor.GetInstance(color));
Hue = value.Item1;
Saturation = value.Item3;
Luminosity = value.Item2;
}
private ColorCMYK(MagickColor color)
: base(color)
{
}
public static void AreNotEqual(MagickColor notExpected, MagickColor actual)
{
if (notExpected.R == actual.R && notExpected.G == actual.G &&
notExpected.B == actual.B && notExpected.A == actual.A)
Assert.Fail("Colors are the same (" + actual.ToString() + ")");
}
/// <summary>
/// Initializes a new instance of the <see cref="ColorRGB"/> class.
/// </summary>
/// <param name="value">The color to use.</param>
public ColorRGB(MagickColor value)
: base(value)
{
}
///<summary>
/// Creates a new DrawableTextUnderColor instance.
///</summary>
///<param name="color">The color to use.</param>
public DrawableTextUnderColor(MagickColor color)
{
Throw.IfNull("color", color);
Color = color;
}
/// <summary>
/// Converts the specified <see cref="MagickColor"/> to an instance of this type.
/// </summary>
/// <param name="color">The color to use.</param>
/// <returns>A <see cref="ColorCMYK"/> instance.</returns>
public static ColorCMYK FromMagickColor(MagickColor color)
{
if (color == null)
return null;
return new ColorCMYK(color);
}
public static void AreEqual(Color expected, MagickColor actual)
{
Assert.IsNotNull(actual);
AreEqual(expected, (Color)actual);
}
private ColorCMYK(MagickColor color)
: base(color)
{
}
private static void TestPixels(MagickImage image, MagickColor color)
{
TestPixels(image, color, color);
}
///<summary>
/// Creates a new DrawableTextUnderColor instance.
///</summary>
///<param name="color">The color to use.</param>
public DrawableTextUnderColor(MagickColor color)
{
Throw.IfNull("color", color);
Color = color;
}
private static void Test_PixelColor(PixelCollection pixels, MagickColor color)
{
Test_PixelColor(pixels, 0, 0, color);
}
private ColorMono(MagickColor color)
: base(color)
{
}
/// <summary>
/// Adds a new instance of the <see cref="DrawableBorderColor" /> class to the <see cref="Drawables" />.
/// </summary>
/// <param name="color">The color of the border.</param>
/// <returns>The <see cref="Drawables" /> instance.</returns>
public Drawables BorderColor(MagickColor color)
{
_drawables.Add(new DrawableBorderColor(color));
return(this);
}
public void FillColor(MagickColor color)
{
_NativeInstance.FillColor(color);
}
///<summary>
/// Converts the specified MagickColor to an instance of this type.
///</summary>
public static ColorGray FromMagickColor(MagickColor color)
{
if (color == null)
return null;
return new ColorGray(color);
}
private ColorGray(MagickColor color)
: base(color)
{
_Shade = Quantum.ScaleToQuantum(color.R);
}
