//===========================================================================================
private static void Test_Pixel(MagickImage image, int x, int y, MagickColor color)
{
using (PixelCollection collection = image.GetReadOnlyPixels())
{
ColorAssert.AreEqual(color, collection.GetPixel(x, y));
}
}
/// <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, MagickColor color)
{
Throw.IfNull(nameof(color), color);
X = x;
Y = y;
Color = color;
}
//===========================================================================================
private static void Test_PixelColor(PixelBaseCollection pixels, Color color)
{
var values = pixels.GetValue(0, 0);
Assert.AreEqual(5, values.Length);
MagickColor magickColor = new MagickColor(values[0], values[1], values[2], values[3]);
ColorAssert.AreEqual(color, magickColor);
}
public static ColorGray FromMagickColor(MagickColor color)
{
object result;
try
{
result = Types.ColorGray.CallMethod("FromMagickColor", new Type[] {Types.MagickColor}, GraphicsMagick.MagickColor.GetInstance(color));
}
catch (Exception ex)
{
throw ExceptionHelper.Create(ex);
}
return (result == null ? null : new ColorGray(result));
}
//===========================================================================================
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_GetValue()
{
using (MagickImage image = new MagickImage(Color.Red, 5, 10))
{
using (PixelCollection pixels = image.GetReadOnlyPixels())
{
var values = pixels.GetValue(0, 0);
Assert.AreEqual(5, values.Length);
MagickColor color = new MagickColor(values[0], values[1], values[2], values[3]);
ColorAssert.AreEqual(Color.Red, color);
}
}
}
public static MagickImage RotateResizeAndFill(MagickImage img, MagickImage size, MagickColor fill) => RotateResizeAndFill(img, new MagickGeometry(size.Width, size.Height), fill);
private static void AreNotEqual(MagickColor expected, Pixel actual)
{
AreNotEqual(expected, actual.ToColor());
}
public BaseBuilder(int Spessore, int dpi, MagickColor fillcolor, MagickColor bordercolor) :
this(Spessore, new Formats(dpi), fillcolor, bordercolor)
{
}
public void Test_Histogram()
{
MagickImage image = new MagickImage(Files.RedPNG);
Dictionary<MagickColor, int> histogram = image.Histogram();
Assert.IsNotNull(histogram);
Assert.AreEqual(1, histogram.Count);
MagickColor red = new MagickColor(Quantum.Max, 0, 0);
Assert.AreEqual(120000, histogram[red]);
}
public static void Erase(string path, List <PatternType> patterns, int scale, MagickColor color)
{
if (patterns.Count < 1)
{
return;
}
MagickImage img = IOUtils.ReadImage(path);
if (img == null)
{
return;
}
PatternType chosenPattern = GetRandomPatternType(patterns);
PreProcessing(path, "- Pattern: " + chosenPattern.ToString());
Random rand = new Random();
MagickImage patternImg = new MagickImage(GetInpaintImage(chosenPattern));
patternImg.FilterType = FilterType.Point;
patternImg.Colorize(color, new Percentage(100));
patternImg.BackgroundColor = MagickColors.Transparent;
patternImg.Rotate(RandRange(0, 360));
double geomW = img.Width * RandRange(1.0f, 2.0f) * GetScaleMultiplier(scale);
double geomH = img.Height * RandRange(1.0f, 2.0f) * GetScaleMultiplier(scale);
//Logger.Log("geomW: " + geomW + " - geomH: " + geomW);
MagickGeometry upscaleGeom = new MagickGeometry(Math.Round(geomW) + "x" + Math.Round(geomH) + "!");
patternImg.Resize(upscaleGeom);
patternImg.BitDepth(Channels.Alpha, 1);
img.Composite(patternImg, Gravity.Center, CompositeOperator.Over);
img.Write(path);
PostProcessing(img, path, path);
}
public void Equals_MagickColorWithConstructedWithStringSetToTransparent_EqualToColorTransparent()
{
MagickColor transparent = new MagickColor("transparent");
ColorAssert.AreEqual(Color.Transparent, transparent);
}
public void Test_ToColor()
{
MagickColor color = new MagickColor(Color.Red);
Assert.AreEqual(Quantum.Max, color.A);
ColorAssert.AreEqual(Color.Red, color);
}
public void Test_IEquatable()
{
MagickColor first = new MagickColor(Color.Red);
Assert.IsFalse(first == null);
Assert.IsFalse(first.Equals(null));
Assert.IsTrue(first.Equals(first));
Assert.IsTrue(first.Equals((object)first));
MagickColor second = new MagickColor(Quantum.Max, 0, 0);
Assert.IsTrue(first == second);
Assert.IsTrue(first.Equals(second));
Assert.IsTrue(first.Equals((object)second));
second = new MagickColor(Color.Green);
Assert.IsTrue(first != second);
Assert.IsFalse(first.Equals(second));
}
public Image CreateCompleteMap(Descr_Strat ds, Descr_Region dr, SMFactions smf)
{
MagickImage regionMap = new MagickImage(dr.FilePathRegions); //use region map to map out regions
MagickImage fullFactionMap = new MagickImage(radarMapLocation); // use radar map as a base
var mag = new MagickGeometry(fullFactionMap.Width, fullFactionMap.Height);
mag.FillArea = true;
mag.IgnoreAspectRatio = true;
regionMap.Alpha(AlphaOption.Remove);
regionMap.AdaptiveResize(mag);
var rpixels = regionMap.GetPixels();
foreach (Faction f in ds.factions) // loop through faction
{
var fpixels = fullFactionMap.GetPixels(); //set up both maps
MagickImage factionMap = new MagickImage(radarMapLocation);
factionMap.Alpha(AlphaOption.Remove);
factionMap.AdaptiveResize(mag);
using (IPixelCollection fmPixels = factionMap.GetPixels())
{
foreach (Settlement s in f.settlements) //loop through settlements to get the regions
{
int[] regColour = dr.GetRGBValue(s.region); //get the colour of a region
MagickColor regCol = MagickColor.FromRgb((byte)regColour[0], (byte)regColour[1], (byte)regColour[2]);
Color facCol1 = smf.GetFactionColour(f.name, 0); //get the faction colour primary
Color facCol2 = smf.GetFactionColour(f.name, 1); // secondary colour
MagickColor priCol = MagickColor.FromRgb(facCol1.R, facCol1.G, facCol1.B); //convert the colours to magickcolour
MagickColor secCol = MagickColor.FromRgb(facCol2.R, facCol2.G, facCol2.B);
int channelsCount = fmPixels.Channels;
for (int y = 0; y < factionMap.Height; y++)
{
List <ushort[]> regVert = new List <ushort[]>(); //create lists to store each pixel along the width of the image
List <ushort[]> facVert = new List <ushort[]>();
if (y - 1 >= 0)
{
regVert.Add(rpixels.GetArea(0, y - 1, regionMap.Width, 1)); // get string of pixels across the image at current y value
facVert.Add(fmPixels.GetArea(0, y - 1, factionMap.Width, 1));
}
regVert.Add(rpixels.GetArea(0, y, regionMap.Width, 1));
facVert.Add(fmPixels.GetArea(0, y, factionMap.Width, 1));
if (y + 1 < regionMap.Height)
{
facVert.Add(fmPixels.GetArea(0, y + 1, factionMap.Width, 1));
regVert.Add(rpixels.GetArea(0, y + 1, regionMap.Width, 1));
}
int i = 0;
if (regVert.Count == 2)
{
i = 0;
}
else
{
i = 1;
}
for (int x = 0; x < regVert[i].Length; x += channelsCount) // traverse each pixel across the image at the current y value
{
MagickColor pixCol = new MagickColor(regVert[i][x], regVert[i][x + 1], regVert[i][x + 2]); //create magickcolour using
MagickColor fCol = new MagickColor(facVert[i][x], facVert[i][x + 1], facVert[i][x + 2]);
if (pixCol == regCol) //compare region colour
{
int bc = BorderCheck(x, i, regVert, regCol); //check if region is a border
if (bc > 1 && bc < 4)
{
fpixels.SetPixel(x == 0 ? x : x / 3, y, Blend(secCol, fCol, 0.6)); ///divide x by 3 to account for the other channels
fmPixels.SetPixel(x == 0 ? x : x / 3, y, Blend(secCol, fCol, 0.6));
}
else
{
fpixels.SetPixel(x == 0 ? x : x / 3, y, Blend(priCol, fCol, 0.6));
fmPixels.SetPixel(x == 0 ? x : x / 3, y, Blend(priCol, fCol, 0.6));
}
}
}
}
}
}
Save(factionMap, f.name, saveLocation);
}
full_map = fullFactionMap;
return(fullFactionMap.ToBitmap());
}
private int BorderCheck(int x, int y, IPixelCollection pixels, MagickImage regionMap, MagickColor mc)
{
int bcount = 0;
if (x + 1 < regionMap.Width)
{
if (pixels[x + 1, y].ToColor() == mc)
{
bcount++;
}
}
if (x - 1 > -1)
{
if (pixels[x - 1, y].ToColor() == mc)
{
bcount++;
}
}
if (y + 1 < regionMap.Height)
{
if (pixels[x, y + 1].ToColor() == mc)
{
bcount++;
}
}
if (y - 1 > -1)
{
if (pixels[x, y - 1].ToColor() == mc)
{
bcount++;
}
}
return(bcount);
}
public void Test_ToString()
{
MagickColor color = new MagickColor(Color.Red);
#if Q8
Assert.AreEqual("#FF0000FF", color.ToString());
#elif Q16
Assert.AreEqual("#FFFF00000000FFFF", color.ToString());
#else
#error Not implemented!
#endif
}
public void Test_Transparent()
{
MagickColor transparent = MagickColor.Transparent;
ColorAssert.IsTransparent(transparent.A);
ColorAssert.AreEqual(Color.Transparent, transparent);
transparent = new MagickColor("transparent");
ColorAssert.IsTransparent(transparent.A);
ColorAssert.AreEqual(Color.Transparent, transparent);
}
public void Test_Read()
{
MagickImage image = new MagickImage();
ExceptionAssert.Throws<ArgumentException>(delegate()
{
image.Read(new byte[0]);
});
ExceptionAssert.Throws<ArgumentNullException>(delegate()
{
image.Read((byte[])null);
});
ExceptionAssert.Throws<ArgumentNullException>(delegate()
{
image.Read((Bitmap)null);
});
ExceptionAssert.Throws<ArgumentNullException>(delegate()
{
image.Read((Stream)null);
});
ExceptionAssert.Throws<ArgumentNullException>(delegate()
{
image.Read((string)null);
});
ExceptionAssert.Throws<ArgumentException>(delegate()
{
image.Read(Files.Missing);
});
ExceptionAssert.Throws<ArgumentException>(delegate()
{
image.Read("png:" + Files.Missing);
});
image.Read(File.ReadAllBytes(Files.SnakewarePNG));
using (Bitmap bitmap = new Bitmap(Files.SnakewarePNG))
{
image.Read(bitmap);
Assert.AreEqual(MagickFormat.Png, image.Format);
}
using (Bitmap bitmap = new Bitmap(100, 100, PixelFormat.Format24bppRgb))
{
image.Read(bitmap);
Assert.AreEqual(MagickFormat.Bmp, image.Format);
}
using (FileStream fs = File.OpenRead(Files.SnakewarePNG))
{
image.Read(fs);
}
image.Read(Files.SnakewarePNG);
image.Read("rose:");
image.Read(Files.RoseSparkleGIF);
Assert.AreEqual("RoseSparkle.gif", Path.GetFileName(image.FileName));
image.Read("png:" + Files.SnakewarePNG);
MagickColor red = new MagickColor("red");
image.Read(red, 50, 50);
Assert.AreEqual(50, image.Width);
Assert.AreEqual(50, image.Height);
Test_Pixel(image, 10, 10, red);
image.Read("xc:red", 50, 50);
Assert.AreEqual(50, image.Width);
Assert.AreEqual(50, image.Height);
Test_Pixel(image, 5, 5, red);
image.Dispose();
ExceptionAssert.Throws<ObjectDisposedException>(delegate()
{
image.Read("logo:");
});
}
public void Test_ColorCMYK()
{
ColorCMYK first = new ColorCMYK(0, 0, 0, 0);
MagickColor second = new MagickColor("cmyk(0,0,0,0)");
Assert.AreEqual(second, first.ToMagickColor());
second = new MagickColor("#fff");
Assert.AreNotEqual(second, first.ToMagickColor());
second = new MagickColor("white");
Assert.AreNotEqual(second, first.ToMagickColor());
first = new ColorCMYK(0, 0, Quantum.Max, 0);
second = new MagickColor("cmyk(0,0,100%,0)");
Assert.AreEqual(second, first.ToMagickColor());
first = new ColorCMYK(0, 0, Quantum.Max, 0, 0);
second = new MagickColor("cmyka(0,0,100%,0,0)");
Assert.AreEqual(second, first.ToMagickColor());
first = new ColorCMYK((Percentage)0, (Percentage)100, (Percentage)0, (Percentage)100);
Assert.AreEqual(0, first.C);
Assert.AreEqual(Quantum.Max, first.M);
Assert.AreEqual(0, first.Y);
Assert.AreEqual(Quantum.Max, first.K);
Assert.AreEqual(Quantum.Max, first.A);
first = new ColorCMYK((Percentage)100, (Percentage)0, (Percentage)100, (Percentage)0, (Percentage)100);
Assert.AreEqual(Quantum.Max, first.C);
Assert.AreEqual(0, first.M);
Assert.AreEqual(Quantum.Max, first.Y);
Assert.AreEqual(0, first.K);
Assert.AreEqual(Quantum.Max, first.A);
first = new ColorCMYK("#0ff0");
Assert.AreEqual(0, first.C);
Assert.AreEqual(Quantum.Max, first.M);
Assert.AreEqual(Quantum.Max, first.Y);
Assert.AreEqual(0, first.K);
Assert.AreEqual(Quantum.Max, first.A);
first = new ColorCMYK("#ff00ff00");
Assert.AreEqual(Quantum.Max, first.C);
Assert.AreEqual(0, first.M);
Assert.AreEqual(Quantum.Max, first.Y);
Assert.AreEqual(0, first.K);
Assert.AreEqual(Quantum.Max, first.A);
first = new ColorCMYK("#0000ffff0000ffff");
Assert.AreEqual(0, first.C);
Assert.AreEqual(Quantum.Max, first.M);
Assert.AreEqual(0, first.Y);
Assert.AreEqual(Quantum.Max, first.K);
Assert.AreEqual(Quantum.Max, first.A);
ExceptionAssert.ThrowsArgumentException("color", () =>
{
new ColorCMYK("white");
});
ExceptionAssert.ThrowsArgumentException("color", () =>
{
new ColorCMYK("#ff00ff");
});
ExceptionAssert.ThrowsArgumentException("color", () =>
{
new ColorCMYK("#ffff0000fffff");
});
ExceptionAssert.ThrowsArgumentException("color", () =>
{
new ColorCMYK("#ffff0000fffff0000fffff");
});
ExceptionAssert.ThrowsArgumentException("color", () =>
{
new ColorCMYK("#fff");
});
}
public ScatolaBuilder(int Spessore, int dpi, MagickColor fillcolor, MagickColor bordercolor) :
base(Spessore, dpi, fillcolor, bordercolor)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="DrawableBorderColor"/> class.
/// </summary>
/// <param name="color">The color of the border.</param>
public DrawableBorderColor(MagickColor color)
{
Throw.IfNull(nameof(color), color);
Color = color;
}
public static MagickImage Gradient(this MagickImage image, MagickColor startColor, MagickColor endColor, double angle = 0)
{
return(Gradient(startColor, endColor, image.Width, image.Height, angle));
}
public void ShouldReturnTrueWhenMagickColorIsConstructedWithTransparentStringAndColorIsTransparent()
{
MagickColor transparent = new MagickColor("transparent");
Assert.IsTrue(transparent.Equals(Color.Transparent));
}
public void ConvertWithString_TypeIsMagickColor_ReturnsValue()
{
MagickColor value = MagickConverter.Convert <MagickColor>("#fff");
ColorAssert.AreEqual(MagickColors.White, value);
}
public void Equals_MagickColorTransparent_EqualToColorTransparent()
{
MagickColor transparent = MagickColors.Transparent;
ColorAssert.AreEqual(Color.Transparent, transparent);
}
private static void Test_PixelColor(PixelCollection pixels, MagickColor color)
{
Test_PixelColor(pixels, 0, 0, color);
}
/// <summary>
/// Initializes a new instance of the <see cref="DrawableStrokeColor"/> class.
/// </summary>
/// <param name="color">The color to use.</param>
public DrawableStrokeColor(MagickColor color)
{
Throw.IfNull(nameof(color), color);
Color = color;
}
public static MagickImage ResizeAndFill(MagickImage img, MagickGeometry size, MagickColor fill)
{
MagickImage i = (MagickImage)img.Clone();
i.Resize(size);
i.Extent(size, Gravity.Center, fill);
return(i);
}
public ScatolaBuilder(int Spessore, Formats formats, MagickColor fillcolor, MagickColor bordercolor) :
base(Spessore, formats, fillcolor, bordercolor)
{
}
public void Test_IComparable()
{
MagickColor first = new MagickColor(Color.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(Color.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(Color.White);
Assert.AreEqual(0, first.CompareTo(second));
Assert.IsFalse(first < second);
Assert.IsTrue(first <= second);
Assert.IsFalse(first > second);
Assert.IsTrue(first >= second);
}
/// <summary>
/// Draw the bounds onto map
/// </summary>
/// <param name="map"></param>
public void Draw(MagickImage map)
{
if (m_bounds.Count == 0)
{
return;
}
MainForm.ProgressStart("Drawing zone bounds ...");
// Sort the polygons
List <List <PointD> > polygons = new List <List <PointD> >();
List <List <PointD> > negatedPolygons = new List <List <PointD> >();
foreach (List <PointF> polygon in m_bounds)
{
bool isClockwise = Tools.PolygonHasClockwiseOrder(polygon);
var polygonConverted = polygon.Select(c => new PointD(zoneConfiguration.ZoneCoordinateToMapCoordinate(c.X), zoneConfiguration.ZoneCoordinateToMapCoordinate(c.Y))).ToList();
// polygons in clockwise order needs to be negated
if (isClockwise)
{
negatedPolygons.Add(polygonConverted);
}
else
{
polygons.Add(polygonConverted);
}
}
MagickColor backgroundColor = MagickColors.Transparent;
if (polygons.Count == 0)
{
// There are no normal polygons, we need to fill the hole zone and substract negatedPolygons
backgroundColor = m_boundsColor;
}
using (MagickImage boundMap = new MagickImage(backgroundColor, zoneConfiguration.TargetMapSize, zoneConfiguration.TargetMapSize))
{
int progressCounter = 0;
boundMap.Alpha(AlphaOption.Set);
boundMap.Settings.FillColor = m_boundsColor;
foreach (List <PointD> coords in polygons)
{
DrawablePolygon poly = new DrawablePolygon(coords);
boundMap.Draw(poly);
progressCounter++;
int percent = 100 * progressCounter / m_bounds.Count();
MainForm.ProgressUpdate(percent);
}
if (negatedPolygons.Count > 0)
{
using (MagickImage negatedBoundMap = new MagickImage(Color.Transparent, zoneConfiguration.TargetMapSize, zoneConfiguration.TargetMapSize))
{
negatedBoundMap.Settings.FillColor = m_boundsColor;
foreach (List <PointD> coords in negatedPolygons)
{
DrawablePolygon poly = new DrawablePolygon(coords);
negatedBoundMap.Draw(poly);
progressCounter++;
int percent = 100 * progressCounter / m_bounds.Count();
MainForm.ProgressUpdate(percent);
}
boundMap.Composite(negatedBoundMap, 0, 0, CompositeOperator.DstOut);
}
}
MainForm.ProgressStartMarquee("Merging ...");
if (ExcludeFromMap)
{
map.Composite(boundMap, 0, 0, CompositeOperator.DstOut);
}
else
{
if (m_transparency != 0)
{
boundMap.Alpha(AlphaOption.Set);
double divideValue = 100.0 / (100.0 - m_transparency);
boundMap.Evaluate(Channels.Alpha, EvaluateOperator.Divide, divideValue);
}
map.Composite(boundMap, 0, 0, CompositeOperator.SrcOver);
}
}
if (debug)
{
DebugMaps();
}
MainForm.ProgressReset();
}
public DrawableTextUnderColor(MagickColor color)
: base(AssemblyHelper.CreateInstance(Types.DrawableTextUnderColor, new Type[] {Types.MagickColor}, GraphicsMagick.MagickColor.GetInstance(color)))
{
}
private static void TestPixels(IMagickImage image, MagickColor color)
{
TestPixels(image, color, color);
}
public void ShouldReturnTheCorrectStringForCmykColor()
{
var color = new MagickColor(0, Quantum.Max, 0, 0, Quantum.Max);
Assert.Equal("cmyk(0," + Quantum.Max + ",0,0)", color.ToShortString());
}
/// <summary>
/// Initializes a new instance of the <see cref="DrawableTextUnderColor"/> class.
/// </summary>
/// <param name="color">The color to use.</param>
public DrawableTextUnderColor(MagickColor color)
{
Throw.IfNull(nameof(color), color);
Color = color;
}
protected static void AssertToString(TColor color, MagickColor expected)
{
Assert.Equal(color.ToString(), expected.ToString());
}
public static MagickImage RotateResizeAndFill(MagickImage img, MagickGeometry size, MagickColor fill) => ResizeAndFill(AutoRotate(img, size), size, fill);
private async void SearchButtonPressed(object sender, RoutedEventArgs e)
{
if (!UrlInput.Text.StartsWith("http://") && !UrlInput.Text.StartsWith("https://"))
{
ErrorText.Visibility = Visibility.Visible;
LoadingSpinner.Visibility = Visibility.Collapsed;
return;
}
ErrorText.Visibility = Visibility.Collapsed;
LoadingSpinner.Visibility = Visibility.Visible;
ExtractionSettings settings = new ExtractionSettings()
{
SvgOnly = false,
RecurseUri = true,
RecurseHyperlinks = true,
HyperlinkRecursionDepth = 3,
LazyDownload = true,
GetMetaTagImages = true,
GetLinkTagImages = true,
GetInlineBackgroundImages = true,
UseCorsAnywhere = false,
DisableValidityCheck = false,
};
settings.OnFoundImage += async(WebImage image) =>
{
try
{
MagickImage img = await image.GetImageAsync();
if (img.Format != MagickFormat.Svg)
{
if (img.Width < 64 || img.Height < 64 || img.Width > 512 || img.Height > 512)
{
return;
}
var size = new MagickGeometry(256, 256);
size.IgnoreAspectRatio = false;
img.Resize(size);
MagickColor mc = new MagickColor(0, 0, 0, 0);
img.Transparent(mc);
img.Format = MagickFormat.Bmp;
}
else
{
Density de = new Density(256, 256);
MagickColor mc = new MagickColor(0, 0, 0, 0);
img.Transparent(mc);
img.Density = de;
img.Settings.TextAntiAlias = true;
img.Format = MagickFormat.Bmp;
}
byte[] bytes = img.ToByteArray();
BitmapImage bitmapImage = LoadImage(bytes);
ListBoxItem boxItem = new ListBoxItem();
Image imageControl = new Image();
imageControl.Width = 96;
imageControl.Height = 96;
imageControl.Source = bitmapImage;
boxItem.Content = imageControl;
boxItem.Selected += (s, args) =>
{
window.SelectedWebsiteImage(img, shortcutControl);
Close();
};
ImageParent.Items.Add(boxItem);
}
catch (Exception)
{
}
};
ImageParent.Items.Clear();
if (cancellationTokenSource != null)
{
cancellationTokenSource.Cancel();
}
numRunning++;
cancellationTokenSource = new CancellationTokenSource();
try
{
await Extractor.GetAllImages(UrlInput.Text.Trim(), settings, cancellationTokenSource.Token);
} catch (Exception)
{
}
numRunning--;
if (numRunning == 0)
{
LoadingSpinner.Visibility = Visibility.Collapsed;
}
}
private static void AreEqual(QuantumType expected, QuantumType actual, MagickColor expectedColor, MagickColor actualColor, float delta, string channel)
{
#if Q16HDRI
if (double.IsNaN(actual))
{
actual = 0;
}
#endif
Assert.AreEqual(expected, actual, delta, channel + " is not equal (" + expectedColor.ToString() + " != " + actualColor.ToString() + ")");
}
private HMXImage(int width, int height)
{
_image = new MagickImage(MagickColor.FromRgb(0, 0, 0), width, height);
}
public void DrawInPaintingMasks(MagickImage mImage, List <Rectangle> maskRegions, MagickColor maskColor,
double maskOversize = 0.0)
{
var drawables = new Drawables();
drawables.StrokeColor(maskColor);
drawables.StrokeOpacity(new Percentage(0));
drawables.FillColor(maskColor);
foreach (var maskRegion in maskRegions)
{
var(x, y, w, h) = (maskRegion.X, maskRegion.Y, maskRegion.Width, maskRegion.Height);
drawables.Rectangle(x - maskOversize, y - maskOversize, x + w + maskOversize * 2.0,
y + h + maskOversize * 2.0);
}
drawables.Draw(mImage);
}
public SparseColorArg(Double x, Double y, MagickColor color)
: this(AssemblyHelper.CreateInstance(Types.SparseColorArg, new Type[] {typeof(Double), typeof(Double), Types.MagickColor}, x, y, GraphicsMagick.MagickColor.GetInstance(color)))
{
}
private IMagickImageInfo CreateIMagickImageInfo(MagickColor color, int width, int height)
{
return(CreateMagickImageInfo(color, width, height));
}
public void ShouldReturnFalseWhenMagickColorAndColorAreDifferent()
{
MagickColor transparent = MagickColors.CadetBlue;
Assert.IsFalse(transparent.Equals(Color.AliceBlue));
}
public void ShouldReturnTrueWhenMagickColorAndColorAreTransparent()
{
MagickColor transparent = MagickColors.Transparent;
Assert.IsTrue(transparent.Equals(Color.Transparent));
}
/// <summary>
/// Initializes a new instance of the <see cref="DrawableStrokeColor"/> class.
/// </summary>
/// <param name="color">The color to use.</param>
public DrawableStrokeColor(MagickColor color)
{
Throw.IfNull(nameof(color), color);
Color = color;
}
