private static void TestPixels(IMagickImage 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 (IMagickImage 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()); } } } } } }
private IMagickImage GenerateMask(IMagickImage original, IMagickImage modified) { int brushWidth = 10; int scale = 10; IMagickImage mask = new MagickImage(MagickColors.Transparent, original.Width, original.Height); mask.Format = MagickFormat.Png; IPixelCollection originalPC = original.GetPixels(); IPixelCollection modifiedPC = modified.GetPixels(); IPixelCollection maskPC = mask.GetPixels(); for (int y = 0; y < original.Height; y++) { for (int x = 0; x < original.Width; x++) { Pixel originalPixel = originalPC.GetPixel(x, y); Pixel modifiedPixel = modifiedPC.GetPixel(x, y); if (!originalPixel.Equals(modifiedPixel)) { Pixel p = maskPC.GetPixel(x, y); p.SetChannel(0, ushort.MaxValue); p.SetChannel(1, 0); p.SetChannel(2, 0); p.SetChannel(3, ushort.MaxValue / 3); } } } return(mask); }
private static void AssertClipColors(bool inside, QuantumType value) { using (IMagickImage image = new MagickImage(Files.InvitationTIF)) { image.Alpha(AlphaOption.Transparent); image.Clip("Pad A", inside); image.Alpha(AlphaOption.Opaque); using (IMagickImage mask = image.GetWriteMask()) { Assert.IsNotNull(mask); Assert.AreEqual(false, mask.HasAlpha); using (IPixelCollection pixels = mask.GetPixels()) { MagickColor pixelA = pixels.GetPixel(0, 0).ToColor(); MagickColor pixelB = pixels.GetPixel(mask.Width - 1, mask.Height - 1).ToColor(); Assert.AreEqual(pixelA, pixelB); Assert.AreEqual(value, pixelA.R); Assert.AreEqual(value, pixelA.G); Assert.AreEqual(value, pixelA.B); MagickColor pixelC = pixels.GetPixel(mask.Width / 2, mask.Height / 2).ToColor(); Assert.AreEqual(Quantum.Max - value, pixelC.R); Assert.AreEqual(Quantum.Max - value, pixelC.G); Assert.AreEqual(Quantum.Max - value, pixelC.B); } } } }
public static void AreEqual(MagickColor expected, IMagickImage image, int x, int y) { using (PixelCollection pixels = image.GetPixels()) { AreEqual(expected, pixels.GetPixel(x, y)); } }
public static void AreNotEqual(MagickColor notExpected, IMagickImage image, int x, int y) { using (PixelCollection collection = image.GetPixels()) { AreNotEqual(notExpected, collection.GetPixel(x, y)); } }
private MagickColor GetBorderColor(IMagickImage image) { using (IPixelCollection pixels = image.GetPixels()) { return(pixels.GetPixel((int)BorderColorLocation.X, (int)BorderColorLocation.Y).ToColor()); } }
public static void CompositeClear(this IMagickImage <byte> image, MagickColor color) { const int BufferSize = 50; using (var pixels = image.GetPixels()) { var colorChannels = pixels.Channels; var colorArray = color.ToByteArray(); var buffer = new byte[BufferSize * BufferSize * colorChannels]; // Create a buffer to reduce native calls and keep memory footprint low. for (var x = 0; x < BufferSize; x++) { for (var y = 0; y < BufferSize; y++) { var destination = colorChannels * (x + (y * BufferSize)); Array.Copy(colorArray, 0, buffer, destination, colorChannels); } } for (var x = 0; x < image.Width; x += BufferSize) { for (var y = 0; y < image.Height; y += BufferSize) { var w = Math.Min(BufferSize, image.Width - x); var h = Math.Min(BufferSize, image.Height - y); var bufferLength = w * h * colorChannels; var actualBuffer = buffer.AsSpan()[..bufferLength];
private static void ResetMaxList(List <PixelValue> maxList, IMagickImage image) { using (var pixels = image.GetPixels()) { var values = pixels.ToShortArray(0, 0, image.Width, 1, "R"); for (int i = 0; i < maxList.Count; i++) { maxList[i].Value = values[maxList[i].Position]; } } }
private void PickImages(bool duplicates) { using var pixels = _template.GetPixels(); var total = pixels.Count(); //Picker var picker = new ImagePicker(_archive, duplicates, total); //Bar var bar = new ProgressBar(total, "Picking images"); foreach (var pixel in pixels) { var point = new Point(pixel.X, pixel.Y); var filename = picker.MostFittingImageFilename(pixel.ToColor()); _images.Add(point, filename); bar.Tick($"Picking image for pixel {point}"); } }
public void CreateImage_WithColor_ReturnsMagickImage() { var color = MagickColors.Goldenrod; MagickFactory factory = new MagickFactory(); using (IMagickImage image = factory.CreateImage(color, 10, 5)) { Assert.IsInstanceOfType(image, typeof(MagickImage)); Assert.AreEqual(10, image.Width); Assert.AreEqual(5, image.Height); using (PixelCollection pixels = image.GetPixels()) { ColorAssert.AreEqual(MagickColors.Goldenrod, image, 0, 0); } } }
public void ShouldReadByteArrayWithPixelStorageSettings() { byte[] data = new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xf0, 0x3f, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xf0, 0x3f, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; var pixelStorageSettings = new PixelStorageSettings(2, 1, StorageType.Double, PixelMapping.RGBA); MagickFactory factory = new MagickFactory(); using (IMagickImage image = factory.CreateImage(data, pixelStorageSettings)) { Assert.AreEqual(2, image.Width); Assert.AreEqual(1, image.Height); using (IPixelCollection pixels = image.GetPixels()) { Pixel pixel = pixels.GetPixel(0, 0); Assert.AreEqual(4, pixel.Channels); Assert.AreEqual(0, pixel.GetChannel(0)); Assert.AreEqual(0, pixel.GetChannel(1)); Assert.AreEqual(0, pixel.GetChannel(2)); Assert.AreEqual(Quantum.Max, pixel.GetChannel(3)); pixel = pixels.GetPixel(1, 0); Assert.AreEqual(4, pixel.Channels); Assert.AreEqual(0, pixel.GetChannel(0)); Assert.AreEqual(Quantum.Max, pixel.GetChannel(1)); Assert.AreEqual(0, pixel.GetChannel(2)); Assert.AreEqual(0, pixel.GetChannel(3)); } } }
private MagickGeometry GetLargestArea(IMagickImage image, MagickColor borderColor) { var points = new Line[4]; using (IPixelCollection pixels = image.GetPixels()) { var line = new Line(0, 0); while (IsBorderColor(pixels, line.X1, line.Y, borderColor) && line.Y < image.Height - 1 && line.X1 < image.Width - 1) { line.Y++; line.X1++; } line.X2 = image.Width - 1; while (IsBorderColor(pixels, line.X2, line.Y, borderColor) && line.X2 > 0) { line.X2--; } points[0] = line; line = new Line(image.Width - 1, 0); while (IsBorderColor(pixels, line.X2, line.Y, borderColor) && line.Y < image.Height && line.X2 > 0) { line.Y++; line.X2--; } line.X1 = 0; while (IsBorderColor(pixels, line.X1, line.Y, borderColor) && line.X1 < image.Width - 1) { line.X1++; } points[1] = line; line = new Line(0, image.Height - 1); while (IsBorderColor(pixels, line.X1, line.Y, borderColor) && line.Y > 0 && line.X1 < image.Width - 1) { line.Y--; line.X1++; } line.X2 = image.Width - 1; while (IsBorderColor(pixels, line.X2, line.Y, borderColor) && line.X2 > 0) { line.X2--; } points[2] = line; line = new Line(image.Width - 1, image.Height - 1); while (IsBorderColor(pixels, line.X2, line.Y, borderColor) && line.Y > 0 && line.X2 > 0) { line.Y--; line.X2--; } line.X1 = 0; while (IsBorderColor(pixels, line.X1, line.Y, borderColor) && line.X1 < image.Width - 1) { line.X1++; } points[3] = line; } var geometry = new MagickGeometry(0, 0); SwapPoints(points); geometry = TestGeometry(geometry, points[0], points[3]); geometry = TestGeometry(geometry, points[1], points[2]); geometry = TestGeometry(geometry, points[0], points[2]); geometry = TestGeometry(geometry, points[1], points[3]); return(geometry); }
private List <List <System.Drawing.Color> > ToPixels(IMagickImage image) { var pixels = image.GetPixels(); return(LinqExtensions.FromTo(0, image.Height).Select(y => LinqExtensions.FromTo(0, image.Width).Select(x => pixels.GetPixel(x, y).ToColor().ToColor()).ToList()).ToList()); }
private NeedleResult FindHighEntropyStrip(IMagickImage image, Gravity gravity, double NeedleSize, StitchTask task) { IProgress <double> progress = task; var pixels = image.GetPixels(); var t1 = DateTime.UtcNow; IEnumerable <int> rows = null; IEnumerable <int> columns = null; Debug.Assert(image.Height > 1 && image.Width > 1, "Assumes non-empty image"); Debug.Assert(image.Width >= NeedleSize, "Assumes image is at least as big as needle size"); var searchArea = NeedleSearchArea(image, gravity); rows = searchArea.Item1; columns = searchArea.Item2; var minY = rows.Min(); var maxY = rows.Max(); var minX = columns.Min(); var maxX = columns.Max(); var imageDimensions = Tuple.Create(image.Width, image.Height); List <List <Pixel> > pixelGrid = LinqExtensions.FromTo(minY, maxY).Select(y => LinqExtensions.FromTo(minX, maxX).Select(x => pixels.GetPixel(x, y)).ToList()).ToList(); List <List <float> > brightnessGrid = pixelGrid.Select(xs => xs.Select(p => p.ToColor().ToColor().GetBrightness()).ToList()).ToList(); var gridWidth = maxX - minX; var gridHeight = maxY - minY; var bestNeedleStddev = 0.0; Point bestNeedle = default(Point); double totalCycles = rows.Count() * columns.Count(); double currentCycle = 0; Console.WriteLine(brightnessGrid); foreach (var y in rows) { foreach (var x in columns) { progress.Report(currentCycle / totalCycles); currentCycle++; if (y - minY + NeedleSize >= gridHeight) { continue; } if (x - minX + NeedleSize >= gridWidth) { continue; } var count = 0; var mean = 0.0; var m2 = 0.0; double blackCount = 0.0; for (var x2 = x - minX; x2 < x - minX + NeedleSize; x2++) { for (var y2 = y - minY; y2 < y - minY + NeedleSize; y2++) { var b = brightnessGrid[y2][x2]; var p = pixelGrid[y2][x2].ToColor(); if (b < 0.08) { blackCount++; } count++; var delta = b - mean; mean = mean + delta / count; var delta2 = b - mean; m2 = m2 + delta * delta2; } } var variance = m2 / (count - 1); var stddev = variance; //Console.WriteLine("{0}, {1}, {2}", blackCount, NeedleSize * NeedleSize, blackCount / (NeedleSize * NeedleSize)); if (stddev > bestNeedleStddev && blackCount / (NeedleSize * NeedleSize) < 0.5) { bestNeedleStddev = stddev; bestNeedle = new Point(x, y); } } } return(new NeedleResult() { Point = bestNeedle, Entropy = bestNeedleStddev }); }