public static void AreEqual(IMagickColor <QuantumType> expected, IMagickImage <QuantumType> image, int x, int y) { using (var pixels = image.GetPixelsUnsafe()) { AreEqual(expected, pixels.GetPixel(x, y), $" at position {x}x{y}"); } }
public static void NotEqual(IMagickColor <QuantumType> notExpected, IMagickColor <QuantumType> actual, string messageSuffix) { if (notExpected.R == actual.R && notExpected.G == actual.G && notExpected.B == actual.B && notExpected.A == actual.A) { throw new XunitException("Colors are the same (" + actual.ToString() + ")" + messageSuffix); } }
public static void AreNotEqual(IMagickColor <QuantumType> notExpected, IMagickImage <QuantumType> image, int x, int y) { using (var collection = image.GetPixelsUnsafe()) { AreNotEqual(notExpected, collection.GetPixel(x, y), $" at position {x}x{y}"); } }
public bool FuzzyEquals(IMagickColor <QuantumType>?other, QuantumType fuzz) { using (var otherNative = MagickColor.CreateInstance(other)) { bool result; #if PLATFORM_AnyCPU if (OperatingSystem.IsArm64) #endif #if PLATFORM_arm64 || PLATFORM_AnyCPU result = NativeMethods.ARM64.MagickColor_FuzzyEquals(Instance, otherNative.Instance, fuzz); #endif #if PLATFORM_AnyCPU else if (OperatingSystem.Is64Bit) #endif #if PLATFORM_x64 || PLATFORM_AnyCPU result = NativeMethods.X64.MagickColor_FuzzyEquals(Instance, otherNative.Instance, fuzz); #endif #if PLATFORM_AnyCPU else #endif #if PLATFORM_x86 || PLATFORM_AnyCPU result = NativeMethods.X86.MagickColor_FuzzyEquals(Instance, otherNative.Instance, fuzz); #endif return(result); } }
private ColorYUV(IMagickColor <QuantumType> color) : base(color) { Y = (1.0 / Quantum.Max) * ((0.298839 * color.R) + (0.586811 * color.G) + (0.11435 * color.B)); U = ((1.0 / Quantum.Max) * ((-0.147 * color.R) - (0.289 * color.G) + (0.436 * color.B))) + 0.5; V = ((1.0 / Quantum.Max) * ((0.615 * color.R) - (0.515 * color.G) - (0.1 * color.B))) + 0.5; }
/// <summary> /// Compares the current instance with another object of the same type. /// </summary> /// <param name="other">The color to compare this color with.</param> /// <returns>A signed number indicating the relative values of this instance and value.</returns> public int CompareTo(IMagickColor <QuantumType>?other) { if (other is null) { return(1); } if (R < other.R) { return(-1); } if (R > other.R) { return(1); } if (G < other.G) { return(-1); } if (G > other.G) { return(1); } if (B < other.B) { return(-1); } if (B > other.B) { return(1); } if (K < other.K) { return(-1); } if (K > other.K) { return(1); } if (A < other.A) { return(-1); } if (A > other.A) { return(1); } return(0); }
internal static INativeInstance CreateInstance(IMagickColor <QuantumType> instance) { if (instance == null) { return(NativeInstance.Zero); } return(MagickColor.CreateNativeInstance(instance)); }
/// <summary> /// Initializes a new instance of the <see cref="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, IMagickColor <QuantumType> color) { Throw.IfNull(nameof(color), color); X = x; Y = y; Color = color; }
private ColorGray(IMagickColor <QuantumType> color) : base(color) { _shade = (0.212656 * Quantum.ScaleToDouble(color.R)) + (0.715158 * Quantum.ScaleToDouble(color.G)) + (0.072186 * Quantum.ScaleToDouble(color.B)); }
public static void AreNotEqual(IMagickColor <QuantumType> notExpected, IMagickColor <QuantumType> actual, string messageSuffix) { 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> /// Converts the specified <see cref="IMagickColor{QuantumType}"/> to an instance of this type. /// </summary> /// <param name="color">The color to use.</param> /// <returns>A <see cref="ColorMono"/> instance.</returns> public static ColorMono?FromMagickColor(IMagickColor <QuantumType> color) { if (color == null) { return(null); } return(new ColorMono(color)); }
/// <summary> /// Converts the specified <see cref="IMagickColor{QuantumType}"/> 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(IMagickColor <QuantumType> color) { if (color is null) { return(null); } return(new ColorCMYK(color)); }
private static void AreEqual(QuantumType expected, QuantumType actual, IMagickColor <QuantumType> expectedColor, IMagickColor <QuantumType> actualColor, float delta, string channel, string messageSuffix) { #if Q16HDRI if (double.IsNaN(actual)) { actual = 0; } #endif Assert.AreEqual(expected, actual, delta, channel + " is not equal (" + expectedColor.ToString() + " != " + actualColor.ToString() + ")" + messageSuffix); }
/// <summary> /// Initializes a new instance of the <see cref="MagickColor"/> class. /// </summary> /// <param name="color">The color to use.</param> public MagickColor(IMagickColor <QuantumType> color) { Throw.IfNull(nameof(color), color); R = color.R; G = color.G; B = color.B; A = color.A; K = color.K; IsCmyk = color.IsCmyk; }
private static NativeMagickColor CreateNativeInstance(IMagickColor <QuantumType> instance) { return(new NativeMagickColor { Red = instance.R, Green = instance.G, Blue = instance.B, Alpha = instance.A, Black = instance.K, IsCMYK = instance.IsCmyk, }); }
private static void Equal(QuantumType expected, QuantumType actual, IMagickColor <QuantumType> expectedColor, IMagickColor <QuantumType> actualColor, double delta, string channel, string messageSuffix) { #if Q16HDRI if (double.IsNaN(actual)) { actual = 0; } #endif if (actual < expected - delta || actual > expected + delta) { throw new XunitException(channel + " is not equal (" + expectedColor.ToString() + " != " + actualColor.ToString() + ") (" + expected + " != " + actual + ") " + messageSuffix); } }
private ColorMono(IMagickColor <QuantumType> color) : base(color) { if (color.Equals(MagickColors.Black)) { IsBlack = true; } else if (color.Equals(MagickColors.White)) { IsBlack = false; } else { throw new ArgumentException("Invalid color specified.", nameof(color)); } }
public static void AreEqual(IMagickColor <QuantumType> expected, IMagickColor <QuantumType> actual, string messageSuffix) { 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, expected, actual, delta, "R", messageSuffix); AreEqual(expected.G, actual.G, expected, actual, delta, "G", messageSuffix); AreEqual(expected.B, actual.B, expected, actual, delta, "B", messageSuffix); AreEqual(expected.A, actual.A, expected, actual, delta, "A", messageSuffix); }
internal static IMagickColor <QuantumType>?Clone(IMagickColor <QuantumType>?value) { if (value == null) { return(value); } return(new MagickColor { R = value.R, G = value.G, B = value.B, A = value.A, K = value.K, IsCmyk = value.IsCmyk, }); }
/// <summary> /// Determines whether the specified color is fuzzy equal to the current color. /// </summary> /// <param name="other">The color to compare this color with.</param> /// <param name="fuzz">The fuzz factor.</param> /// <returns>True when the specified color is fuzzy equal to the current instance.</returns> public bool FuzzyEquals(IMagickColor <QuantumType> other, Percentage fuzz) { if (other is null) { return(false); } if (ReferenceEquals(this, other)) { return(true); } using (NativeMagickColor instance = CreateNativeInstance(this)) { return(instance.FuzzyEquals(other, fuzz.ToQuantumType())); } }
public void SetFillColor(IMagickColor <QuantumType>?value) { using (var valueNative = MagickColor.CreateInstance(value)) { #if PLATFORM_AnyCPU if (OperatingSystem.Is64Bit) #endif #if PLATFORM_x64 || PLATFORM_AnyCPU NativeMethods.X64.MontageSettings_SetFillColor(Instance, valueNative.Instance); #endif #if PLATFORM_AnyCPU else #endif #if PLATFORM_x86 || PLATFORM_AnyCPU NativeMethods.X86.MontageSettings_SetFillColor(Instance, valueNative.Instance); #endif } }
public void SetStrokeColor(IMagickColor <QuantumType> value) { using (INativeInstance valueNative = MagickColor.CreateInstance(value)) { #if PLATFORM_AnyCPU if (NativeLibrary.Is64Bit) #endif #if PLATFORM_x64 || PLATFORM_AnyCPU NativeMethods.X64.MontageSettings_SetStrokeColor(Instance, valueNative.Instance); #endif #if PLATFORM_AnyCPU else #endif #if PLATFORM_x86 || PLATFORM_AnyCPU NativeMethods.X86.MontageSettings_SetStrokeColor(Instance, valueNative.Instance); #endif } }
public bool FuzzyEquals(IMagickColor <QuantumType> other, QuantumType fuzz) { using (INativeInstance otherNative = MagickColor.CreateInstance(other)) { #if PLATFORM_AnyCPU if (OperatingSystem.Is64Bit) #endif #if PLATFORM_x64 || PLATFORM_AnyCPU return(NativeMethods.X64.MagickColor_FuzzyEquals(Instance, otherNative.Instance, fuzz)); #endif #if PLATFORM_AnyCPU else #endif #if PLATFORM_x86 || PLATFORM_AnyCPU return(NativeMethods.X86.MagickColor_FuzzyEquals(Instance, otherNative.Instance, fuzz)); #endif } }
/// <summary> /// Determines whether the specified color is equal to the current color. /// </summary> /// <param name="other">The color to compare this color with.</param> /// <returns>True when the specified color is equal to the current color.</returns> public bool Equals(IMagickColor <QuantumType>?other) { if (other is null) { return(false); } if (ReferenceEquals(this, other)) { return(true); } return (IsCmyk == other.IsCmyk && A == other.A && B == other.B && G == other.G && R == other.R && K == other.K); }
public static string GetAverageHtmlColourFromImageStreamUsingScale(int frameTime, string file, VideoCollection videoCollection, SettingsWrapper settings) { SetTempDir(settings); using MemoryStream ms = new MemoryStream(); new NReco.VideoConverter.FFMpegConverter().GetVideoThumbnail(videoCollection.Config.FullPath, ms, frameTime); if (ms.Length == 0) { return(null); } Image.FromStream(ms).Save(Path.Combine(videoCollection.Config.ImageDirectory, file), ImageFormat.Jpeg); ms.Seek(0, SeekOrigin.Begin); using MagickImage image = new MagickImage(ms, new MagickReadSettings { Format = MagickFormat.Jpeg }); image.Crop(new MagickGeometry(new Percentage(70), new Percentage(70)), Gravity.Center); image.Scale(1, 1); IMagickColor <byte> color = image.GetPixels().First().ToColor(); return(ColorTranslator.ToHtml(Color.FromArgb(color.A, color.R, color.G, color.B))); }
/// <summary> /// Initializes a new instance of the <see cref="DrawableTextUnderColor"/> class. /// </summary> /// <param name="color">The color to use.</param> public DrawableTextUnderColor(IMagickColor <QuantumType> color) { Throw.IfNull(nameof(color), color); Color = color; }
private static void AreNotEqual(IMagickColor <QuantumType> expected, IPixel <QuantumType> actual, string messageSuffix) => AreNotEqual(expected, actual.ToColor(), messageSuffix);
/// <summary> /// Initializes a new instance that implements <see cref="IMagickImage{TQuantumType}"/>. /// </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{TQuantumType}"/> instance.</returns> public IMagickImage <QuantumType> Create(IMagickColor <QuantumType> color, int width, int height) => new MagickImage(color, width, height);
public static void AreNotEqual(IMagickColor <QuantumType> notExpected, IMagickColor <QuantumType> actual) => AreNotEqual(notExpected, actual, null);
public static void AreEqual(IMagickColor <QuantumType> expected, IMagickColor <QuantumType> actual) => AreEqual(expected, actual, null);