private static void DoLosslessCompress(FileInfo file) { using (MagickImageCollection images = new MagickImageCollection(file)) { if (images.Count == 1) { DoLosslessCompress(file, images[0]); return; } } }
public void Test_Collection_Exceptions() { using (MagickImageCollection collection = new MagickImageCollection()) { MagickReadSettings settings = new MagickReadSettings(); settings.PixelStorage = new PixelStorageSettings(); ExceptionAssert.Throws<ArgumentException>(delegate() { collection.Read(Files.RoseSparkleGIF, settings); }); } }
public void Test_Collection_Read() { using (MagickImageCollection collection = new MagickImageCollection()) { MagickReadSettings settings = new MagickReadSettings(); settings.Density = new MagickGeometry(150, 150); collection.Read(Files.RoseSparkleGIF, settings); Assert.AreEqual(150, collection[0].Density.Width); settings = null; collection.Read(Files.RoseSparkleGIF, settings); } }
public void Test_AddRange() { using (MagickImageCollection collection = new MagickImageCollection(Files.RoseSparkleGIF)) { Assert.AreEqual(3, collection.Count); collection.AddRange(Files.RoseSparkleGIF); Assert.AreEqual(6, collection.Count); collection.AddRange(collection); Assert.AreEqual(12, collection.Count); List<MagickImage> images = new List<MagickImage>(); images.Add(new MagickImage("xc:red", 100, 100)); collection.AddRange(images); Assert.AreEqual(13, collection.Count); } }
public void ShouldReadTheProfileForAllLayers() { var readSettings = new MagickReadSettings { Defines = new PsdReadDefines { ReplicateProfile = true, }, }; using (var images = new MagickImageCollection(Files.Coders.LayerStylesSamplePSD, readSettings)) { Assert.Equal(4, images.Count); foreach (var image in images) { Assert.NotNull(image.Get8BimProfile()); } } }
public void ShouldUseTheSpecifiedFormat() { using (var input = new MagickImageCollection(Files.CirclePNG)) { using (var memoryStream = new MemoryStream()) { using (var stream = new NonSeekableStream(memoryStream)) { input.Write(stream, MagickFormat.Tiff); memoryStream.Position = 0; using (var output = new MagickImageCollection(stream)) { Assert.Single(output); Assert.Equal(MagickFormat.Tiff, output[0].Format); } } } } }
public static void MergeMultipleImages() { using (MagickImageCollection images = new MagickImageCollection()) { // Add the first image MagickImage first = new MagickImage(SampleFiles.SnakewarePng); images.Add(first); // Add the second image MagickImage second = new MagickImage(SampleFiles.SnakewarePng); images.Add(second); // Create a mosaic from both images using (IMagickImage result = images.Mosaic()) { // Save the result result.Write(SampleFiles.OutputDirectory + "Mosaic.png"); } } }
public static void ResizeAnimatedGif() { // Read from file using (MagickImageCollection collection = new MagickImageCollection(SampleFiles.SnakewareGif)) { // This will remove the optimization and change the image to how it looks at that point // during the animation. More info here: http://www.imagemagick.org/Usage/anim_basics/#coalesce collection.Coalesce(); // Resize each image in the collection to a width of 200. When zero is specified for the height // the height will be calculated with the aspect ratio. foreach (MagickImage image in collection) { image.Resize(200, 0); } // Save the result collection.Write(SampleFiles.OutputDirectory + "Snakeware.resized.gif"); } }
public void ShouldUseTheFileExtension() { var readSettings = new MagickReadSettings { Format = MagickFormat.Png, }; using (var input = new MagickImageCollection(Files.CirclePNG, readSettings)) { using (var tempFile = new TemporaryFile(".jpg")) { input.Write(tempFile); using (var output = new MagickImageCollection(tempFile)) { Assert.Equal(MagickFormat.Jpeg, output[0].Format); } } } }
static public Stream AsOneImageToStream(string fileName, MagickFormat imageExtension) { Stream stream = new MemoryStream(); var settings = new MagickReadSettings(); settings.Density = new Density(300); using (var images = new MagickImageCollection()) { images.Read(fileName, settings); using (var vertical = images.AppendVertically()) { vertical.Format = imageExtension; vertical.Write(stream); } } return(stream); }
private MagickImage CreateLinearTexture() { MagickImage gradient = new MagickImage("gradient:", Thickness, Thickness * 4); gradient.Rotate(270); MagickImage thick1 = CreateRolled(gradient, Thickness); MagickImage thick2 = CreateRolled(gradient, Thickness * 2); MagickImage thick3 = CreateRolled(gradient, Thickness * 3); using (MagickImageCollection images = new MagickImageCollection()) { images.Add(gradient); images.Add(thick1); images.Add(thick2); images.Add(thick3); return(images.AppendVertically()); } }
internal static void GenerateImagesFromPdf(FileInfo pdfFile, DirectoryInfo directoryToSaveImages) { var settings = new MagickReadSettings { Density = new Density(96, 96) }; using (var images = new MagickImageCollection()) { images.Read(pdfFile, settings); var page = 1; Console.WriteLine($"Saving generated image from pdf to {directoryToSaveImages.FullName}"); foreach (var magickImage in images) { var outputFile = new FileInfo(Path.Combine(directoryToSaveImages.FullName, pdfFile.Name + "_" + page + ".png")); magickImage.Write(outputFile); page++; } } }
public static void ReadSinglePageFromPDF() { using (MagickImageCollection collection = new MagickImageCollection()) { MagickReadSettings settings = new MagickReadSettings(); settings.FrameIndex = 0; // First page settings.FrameCount = 1; // Number of pages // Read only the first page of the pdf file collection.Read(SampleFiles.SnakewarePdf, settings); // Clear the collection collection.Clear(); settings.FrameCount = 2; // Number of pages // Read the first two pages of the pdf file collection.Read(SampleFiles.SnakewarePdf, settings); } }
public static void ReadImageWithMultipleFrames() { // Read from file using (MagickImageCollection collection = new MagickImageCollection(SampleFiles.SnakewareJpg)) { } // Read from stream using (MemoryStream memStream = LoadMemoryStreamImage()) { using (MagickImageCollection collection = new MagickImageCollection(memStream)) { } } // Read from byte array byte[] data = LoadImageBytes(); using (MagickImageCollection collection = new MagickImageCollection(data)) { } // Read pdf with custom density. MagickReadSettings settings = new MagickReadSettings(); settings.Density = new Density(144); using (MagickImageCollection collection = new MagickImageCollection(SampleFiles.SnakewarePdf, settings)) { } using (MagickImageCollection collection = new MagickImageCollection()) { collection.Read(SampleFiles.SnakewareJpg); using (MemoryStream memStream = LoadMemoryStreamImage()) { collection.Read(memStream); } collection.Read(data); collection.Read(SampleFiles.SnakewarePdf, settings); } }
private void btnSplit_Click(object sender, EventArgs e) { DateTime dt_start = System.DateTime.Now; MagickReadSettings settings = new MagickReadSettings(); settings.Density = new MagickGeometry(300, 300); OpenFileDialog dlg = new OpenFileDialog(); if (dlg.ShowDialog() == DialogResult.OK) { string dbt_wfile = dlg.FileName; string pdfFolderPath = Path.Combine(Path.GetDirectoryName(dbt_wfile), Path.GetFileNameWithoutExtension(dbt_wfile)); if (!Directory.Exists(pdfFolderPath)) { Directory.CreateDirectory(pdfFolderPath); } int count = NCPDF.CountPageNo(dbt_wfile); using (MagickImageCollection images = new MagickImageCollection()) { for (int idx = 0; idx < count; idx++) { string pdf_file = Path.Combine(pdfFolderPath, idx.ToString() + ".pdf"); NCPDF.ExtractPages(dbt_wfile, pdf_file, idx + 1, idx + 1); images.Read(pdf_file, settings); //int page = 0; foreach (MagickImage image in images) { if (!File.Exists(pdfFolderPath + "\\image" + idx + ".jpg")) { image.Write(pdfFolderPath + "\\image" + idx + ".jpg"); } //page++; } File.Delete(pdf_file); } } } MessageBox.Show(DateTime.Now.Subtract(dt_start).Duration().Seconds.ToString()); }
public void Test_Flatten() { using (IMagickImageCollection collection = new MagickImageCollection()) { ExceptionAssert.Throws <InvalidOperationException>(delegate() { collection.Flatten(); }); collection.Add(new MagickImage(MagickColors.Brown, 10, 10)); IMagickImage center = new MagickImage(MagickColors.Fuchsia, 4, 4); center.Page = new MagickGeometry(3, 3, 4, 4); collection.Add(center); using (IMagickImage image = collection.Flatten()) { ColorAssert.AreEqual(MagickColors.Brown, image, 0, 0); ColorAssert.AreEqual(MagickColors.Fuchsia, image, 5, 5); } } }
public void ShouldUseTheCorrectReaderWhenFormatIsSet() { var bytes = Encoding.ASCII.GetBytes("%PDF-"); var settings = new MagickReadSettings { Format = MagickFormat.Png, }; using (MemoryStream stream = new MemoryStream(bytes)) { using (var images = new MagickImageCollection()) { var exception = Assert.Throws <MagickCorruptImageErrorException>(() => { images.Read(stream, settings); }); Assert.Contains("ReadPNGImage", exception.Message); } } }
public void Test_AdditionalInfo() { using (IMagickImageCollection images = new MagickImageCollection()) { images.Read(Files.Coders.LayerStylesSamplePSD); CheckProfile(images[1], 264); var defines = new PsdWriteDefines() { AdditionalInfo = PsdAdditionalInfo.All }; WriteAndCheckProfile(images, defines, 264); defines.AdditionalInfo = PsdAdditionalInfo.Selective; WriteAndCheckProfile(images, defines, 152); defines.AdditionalInfo = PsdAdditionalInfo.None; WriteAndCheckProfile(images, defines, 0); } }
public void Test_Montage() { using (MagickImageCollection images = new MagickImageCollection()) { for (int i = 0; i < 9; i++) { images.Add(Files.Builtin.Logo); } MontageSettings ms = new MontageSettings(); ms.Geometry = new MagickGeometry(string.Format("{0}x{1}", 200, 200)); ms.TileGeometry = new MagickGeometry(string.Format("{0}x", 2)); using (MagickImage montageResult = images.Montage(ms)) { Assert.IsNotNull(montageResult); Assert.AreEqual(400, montageResult.Width); Assert.AreEqual(1000, montageResult.Height); } } }
public void ShouldMergeTheImages() { using (IMagickImageCollection collection = new MagickImageCollection()) { collection.Read(Files.RoseSparkleGIF); using (IPixelCollection pixels = collection[1].GetPixels()) { MagickColor color = pixels.GetPixel(53, 3).ToColor(); Assert.AreEqual(0, color.A); } collection.Coalesce(); using (IPixelCollection pixels = collection[1].GetPixels()) { MagickColor color = pixels.GetPixel(53, 3).ToColor(); Assert.AreEqual(Quantum.Max, color.A); } } }
/// <summary> /// Generates frames for .gif image /// </summary> /// <param name="imageCollection">Object for Stack Images</param> /// <param name="text">Text to be Draw</param> /// <param name="counter">Stack number</param> /// <returns></returns> public static MagickImageCollection FramesGeneration(MagickImageCollection imageCollection, string text, int counter) { Image image = null; ImageConverter converter = new ImageConverter(); if (imageCollection == null) { imageCollection = new MagickImageCollection(); } image = DrawText(text); byte[] buffer = (byte[])converter.ConvertTo(image, typeof(byte[])); var imageMagick = new MagickImage(buffer); imageCollection.Add(imageMagick); imageCollection[counter].AnimationDelay = 100; converter = null; return(imageCollection); }
private string GetTheGif(IndexViewModel model) { if (model == null || model.TheImages == null || model.TheImages.Count == 0) { return(null); } string imageBase64 = null; string webRootPath = _hostingEnvironment.WebRootPath; model.TheImages = OrderAndExtend(model.TheImages); using (MagickImageCollection frames = CreateFrameCollection(model)) { // Save gif MemoryStream ms = new MemoryStream(); frames.Write(ms, MagickFormat.Gif); imageBase64 = Convert.ToBase64String(ms.ToArray()); } return(imageBase64); }
public void ShouldMakeSetWhichAdditionalInfoShouldBeWritten() { using (var images = new MagickImageCollection()) { images.Read(Files.Coders.LayerStylesSamplePSD); CheckProfile(images[1], 264); var defines = new PsdWriteDefines { AdditionalInfo = PsdAdditionalInfoPart.All, }; WriteAndCheckProfile(images, defines, 264); defines.AdditionalInfo = PsdAdditionalInfoPart.Selective; WriteAndCheckProfile(images, defines, 152); defines.AdditionalInfo = PsdAdditionalInfoPart.None; WriteAndCheckProfile(images, defines, 0); } }
public override void ExportVignette(Context context, string outputDir) { var s = context.Deserializer; var vignetteLists = new string[] { "intro", "outro" }; foreach (var p in vignetteLists) { var vigPath = p + ".dat"; if (!context.FileExists(vigPath)) { continue; } var vigListFile = FileFactory.Read <LUDI_PocketPC_DataFile>(vigPath, context); s.DoAt(vigListFile.Resolve(1), () => { using (MagickImageCollection collection = new MagickImageCollection()) { var video = s.SerializeObject <LUDI_Video>(default, name: p);
public void Test_Write() { long fileSize; using (IMagickImage image = new MagickImage(Files.RoseSparkleGIF)) { fileSize = image.FileSize; } Assert.AreEqual(fileSize, 9891); using (IMagickImageCollection collection = new MagickImageCollection(Files.RoseSparkleGIF)) { using (MemoryStream memStream = new MemoryStream()) { collection.Write(memStream); Assert.AreEqual(fileSize, memStream.Length); } } FileInfo tempFile = new FileInfo(Path.GetTempFileName() + ".gif"); try { using (IMagickImageCollection collection = new MagickImageCollection(Files.RoseSparkleGIF)) { collection.Write(tempFile); Assert.AreEqual(fileSize, tempFile.Length); } } finally { if (tempFile.Exists) { tempFile.Delete(); } } }
public void Test_OptimizePlus() { using (IMagickImageCollection collection = new MagickImageCollection()) { ExceptionAssert.Throws <InvalidOperationException>(() => { collection.OptimizePlus(); }); collection.Add(new MagickImage(MagickColors.Red, 11, 11)); /* the second image will not be removed if it is a duplicate so we * need to add an extra one. */ collection.Add(new MagickImage(MagickColors.Red, 11, 11)); collection.Add(new MagickImage(MagickColors.Red, 11, 11)); IMagickImage image = new MagickImage(MagickColors.Red, 11, 11); using (var pixels = image.GetPixels()) { pixels.SetPixel(5, 5, new QuantumType[] { 0, Quantum.Max, 0 }); } collection.Add(image); collection.OptimizePlus(); Assert.AreEqual(3, collection.Count); Assert.AreEqual(1, collection[1].Width); Assert.AreEqual(1, collection[1].Height); Assert.AreEqual(-1, collection[1].Page.X); Assert.AreEqual(-1, collection[1].Page.Y); ColorAssert.AreEqual(MagickColors.Red, collection[1], 0, 0); Assert.AreEqual(1, collection[2].Width); Assert.AreEqual(1, collection[2].Height); Assert.AreEqual(5, collection[2].Page.X); Assert.AreEqual(5, collection[2].Page.Y); ColorAssert.AreEqual(MagickColors.Lime, collection[2], 0, 0); } }
public static FileInfo ConvertPdfToPng(FileInfo pdfFile) { if (pdfFile.DirectoryName == null) { throw new ArgumentException("file directory was null. why?"); } MagickReadSettings imsettings = new MagickReadSettings { Density = new PointD(300, 300), // Settings the density to 300 dpi will create an image with a better quality FrameIndex = 0, // first page FrameCount = 1, // number of pages Format = MagickFormat.Pdf }; const MagickFormat imageOutputFormat = MagickFormat.Png; var pngFilename = GetFileNameWithoutExtension(pdfFile) + "." + imageOutputFormat.ToString(); var pngFile = new FileInfo(Path.Combine(pdfFile.DirectoryName, pngFilename)); try { // note that this "collection" is a bunch of pages in a pdf, and actually only 1 because we are limiting it to page 1. using (var images = new MagickImageCollection()) { // Add all the pages of the pdf file to the collection images.Read(pdfFile, imsettings); foreach (var image in images) { image.Format = imageOutputFormat; image.Write(pngFile); } } return(pngFile); } catch (Exception exception) { Console.WriteLine(exception); throw; } }
public static void Process(string path) { var filename = Path.GetFileNameWithoutExtension(path); if (path.Contains(".gif")) { using (MagickImage image = new MagickImage(path)) { // Save frame as jpg image.Write("/Images/results/" + filename + ".jpg"); } } else if (path.Contains(".pdf")) { MagickReadSettings settings = new MagickReadSettings(); // Settings the density to 150 dpi will create an image with a better quality settings.Density = new Density(150, 150); using (MagickImageCollection images = new MagickImageCollection()) { // Add all the pages of the pdf file to the collection images.Read(path, settings); int page = 1; foreach (MagickImage image in images) { // Write page to file that contains the page number image.Write("/Images/results/" + filename + ".Page" + page + ".png"); // Writing to a specific format works the same as for a single image image.Format = MagickFormat.Tif; image.Write("/Images/results/" + filename + ".Page" + page + ".tif"); page++; } } } else { throw new NotImplementedException("File type not supported"); } }
/// <summary> /// Load the given page from the PDF /// </summary> /// <param name="pageNumber">Page number to load</param> /// <returns>Bitmap representing page</returns> protected override async Task <Bitmap> LoadPage(int pageNumber) { using (var collection = new MagickImageCollection()) { using (var stream = new MemoryStream()) { return(await Task.Run(() => { var settings = new MagickReadSettings(); // Page to read settings.FrameIndex = pageNumber; // Number of pages to read settings.FrameCount = 1; // This is currently just a "best guess" at the proper density to read the image at // There wasn't an obvious way to get the actual density of the screen from Avalonia settings.Density = new Density(200); // Read only the given page of the pdf file collection.Read(base.FilePath, settings); var img = collection[0]; // Write a PNG to a stream, then pass that to an Avalonia Bitmap img.Write(stream, MagickFormat.Png); stream.Position = 0; var bitmap = new Bitmap(stream); // Clear the collection collection.Clear(); return Task.FromResult(bitmap); })); } } throw new System.Exception("Error loading page from PDF " + FilePath); }
private static byte[] ProcessGif(int requestWidth, int requestHeight, int quality, byte[] bytes, string options) { using (MagickImageCollection collection = new MagickImageCollection(bytes)) { collection.Coalesce(); // the height will be calculated with the aspect ratio. foreach (var magickImage in collection) { var gifImage = (MagickImage)magickImage; ResizeImage(requestWidth, requestHeight, quality, options, gifImage); } collection.RePage(); collection.Optimize(); collection.OptimizeTransparency(); // Save the result return(collection.ToByteArray()); } }
public void ConvertToScanned(string filename) { MagickReadSettings settings = new MagickReadSettings { Density = new Density(300, 300) }; MagickNET.SetGhostscriptDirectory(Path.GetDirectoryName(GhostScriptHelper.GetGhostscriptVersion().DllPath)); List <string> scannedimgfiles = new List <string>(); using (MagickImageCollection images = new MagickImageCollection()) { images.Read(filename, settings); int page = 1; foreach (MagickImage image in images) { image.ColorSpace = ColorSpace.Gray; var clone = image.Clone(); clone.Blur(0, 1); clone.Compose = CompositeOperator.DivideDst; image.Composite(clone); image.LinearStretch(new Percentage(5), new Percentage(0)); image.Rotate(0.2); var tempimgpath = Path.GetTempPath() + Path.GetFileNameWithoutExtension(filename) + "_img_" + page + ".png"; image.Write(tempimgpath); scannedimgfiles.Add(tempimgpath); page++; } } new ITextHelper().ImageToPdf(scannedimgfiles, filename); scannedimgfiles.ForEach(f => File.Delete(f)); }
public void Test_Morph() { using (IMagickImageCollection collection = new MagickImageCollection()) { ExceptionAssert.Throws <InvalidOperationException>(delegate() { collection.Morph(10); }); collection.Add(Files.Builtin.Logo); ExceptionAssert.Throws <InvalidOperationException>(delegate() { collection.Morph(10); }); collection.AddRange(Files.Builtin.Wizard); collection.Morph(4); Assert.AreEqual(6, collection.Count); } }
public void ShouldCorrectlyOptimizeTheImages() { using (IMagickImageCollection collection = new MagickImageCollection()) { collection.Add(new MagickImage(MagickColors.Red, 11, 11)); var image = new MagickImage(MagickColors.Red, 11, 11); using (var pixels = image.GetPixels()) { pixels.SetPixel(5, 5, new QuantumType[] { 0, Quantum.Max, 0 }); } collection.Add(image); collection.Optimize(); Assert.AreEqual(1, collection[1].Width); Assert.AreEqual(1, collection[1].Height); Assert.AreEqual(5, collection[1].Page.X); Assert.AreEqual(5, collection[1].Page.Y); ColorAssert.AreEqual(MagickColors.Lime, collection[1], 0, 0); } }
public Task <MagickImageCollection> SpoilerImg(string uri) => Task.Run(async() => { //load image var img2 = await DownloadImageAsync(uri); //create spoiler warning image Image <Rgba32> img1 = new Image <Rgba32>(img2.Width, img2.Height); _Spoil = _fonts.Find("Whitney-Bold").CreateFont(img2.Width * 0.064f); var fill = Brushes.Solid <Rgba32>(Rgba32.Black); var brush = Brushes.Solid <Rgba32>(Rgba32.White); var rect = new Rectangle(0, 0, img2.Width, img2.Height); img1.BackgroundColor(Rgba32.Black, rect); img1.DrawText("Spoiler Warning" + "\r\n" + "(Mouse over to view)", _Spoil, brush, new PointF(10, 10), new TextGraphicsOptions(true) { WrapTextWidth = img1.Width - 20 }); MagickImage f1 = new MagickImage(img1.ToStream()); MagickImage f2 = new MagickImage(img2.ToStream()); MagickImage[] frames = { f1, f2 }; var gifs = GetGif(frames); var gif = new MagickImageCollection(gifs); return(gif); });
public void Test_Append() { int width = 70; int height = 46; using (MagickImageCollection collection = new MagickImageCollection(Files.RoseSparkleGIF)) { Assert.AreEqual(width, collection[0].Width); Assert.AreEqual(height, collection[0].Height); using (MagickImage image = collection.AppendHorizontally()) { Assert.AreEqual(width * 3, image.Width); Assert.AreEqual(height, image.Height); } using (MagickImage image = collection.AppendVertically()) { Assert.AreEqual(width, image.Width); Assert.AreEqual(height * 3, image.Height); } } }
public void Test_Reverse() { using (MagickImageCollection collection = new MagickImageCollection(Files.RoseSparkleGIF)) { MagickImage first = collection.First(); collection.Reverse(); MagickImage last = collection.Last(); Assert.IsTrue(last == first); } }
public void Test_Write() { long fileSize; using (MagickImage image = new MagickImage(Files.RoseSparkleGIF)) { fileSize = image.FileSize; } using (MagickImageCollection collection = new MagickImageCollection(Files.RoseSparkleGIF)) { using (MemoryStream memStream = new MemoryStream()) { collection.Write(memStream); Assert.AreEqual(fileSize, memStream.Length); } } }
public void Test_Index() { using (MagickImageCollection collection = new MagickImageCollection(Files.RoseSparkleGIF)) { for (int i = 0; i < collection.Count; i++) { collection[i].Scale(35, 23); Assert.AreEqual(35, collection[i].Width); collection[i] = collection[i]; Assert.AreEqual(35, collection[i].Width); collection[i] = null; } } }
public void Test_Dispose() { MagickImage image = new MagickImage(Color.Red, 10, 10); MagickImageCollection collection = new MagickImageCollection(); collection.Add(image); collection.Dispose(); Assert.AreEqual(0, collection.Count); image.Wave(); }
public void Test_RePage() { using (MagickImageCollection collection = new MagickImageCollection(Files.RoseSparkleGIF)) { collection[0].Page = new MagickGeometry("0x0+10+10"); Assert.AreEqual(10, collection[0].Page.X); Assert.AreEqual(10, collection[0].Page.Y); collection.RePage(); Assert.AreEqual(0, collection[0].Page.X); Assert.AreEqual(0, collection[0].Page.Y); } }
public void Test_CopyTo() { using (MagickImageCollection collection = new MagickImageCollection()) { collection.Add(new MagickImage(Files.SnakewarePNG)); collection.Add(new MagickImage(Files.RoseSparkleGIF)); MagickImage[] images = new MagickImage[collection.Count]; collection.CopyTo(images, 0); Assert.AreEqual(collection[0], images[0]); Assert.AreNotEqual(collection[0], images[1]); collection.CopyTo(images, 1); Assert.AreEqual(collection[0], images[0]); Assert.AreEqual(collection[0], images[1]); images = new MagickImage[collection.Count + 1]; collection.CopyTo(images, 0); images = new MagickImage[1]; collection.CopyTo(images, 0); ExceptionAssert.Throws<ArgumentNullException>(delegate() { collection.CopyTo(null, -1); }); ExceptionAssert.Throws<ArgumentOutOfRangeException>(delegate() { collection.CopyTo(images, -1); }); } }
public void Test_Remove() { using (MagickImageCollection collection = new MagickImageCollection(Files.RoseSparkleGIF)) { MagickImage first = collection[0]; collection.Remove(first); Assert.AreEqual(2, collection.Count); Assert.AreEqual(-1, collection.IndexOf(first)); first = collection[0]; collection.RemoveAt(0); Assert.AreEqual(1, collection.Count); Assert.AreEqual(-1, collection.IndexOf(first)); } }
public void Test_ToBitmap() { using (MagickImageCollection collection = new MagickImageCollection(Files.RoseSparkleGIF)) { Assert.AreEqual(3, collection.Count); Bitmap bitmap = collection.ToBitmap(); Assert.IsNotNull(bitmap); Assert.AreEqual(3, bitmap.GetFrameCount(FrameDimension.Page)); } }
public void Test_Morph() { using (MagickImageCollection collection = new MagickImageCollection(Files.RoseSparkleGIF)) { Assert.AreEqual(3, collection.Count); using (MagickImageCollection morphed = collection.Morph(2)) { Assert.AreEqual(7, morphed.Count); } } }
public void Test_Read() { MagickImageCollection collection = new MagickImageCollection(); ExceptionAssert.Throws<ArgumentException>(delegate() { collection.Read(new byte[0]); }); ExceptionAssert.Throws<ArgumentNullException>(delegate() { collection.Read((byte[])null); }); ExceptionAssert.Throws<ArgumentNullException>(delegate() { collection.Read((Stream)null); }); ExceptionAssert.Throws<ArgumentNullException>(delegate() { collection.Read((string)null); }); ExceptionAssert.Throws<ArgumentException>(delegate() { collection.Read(Files.Missing); }); collection.Read(File.ReadAllBytes(Files.RoseSparkleGIF)); Assert.AreEqual(3, collection.Count); using (FileStream fs = File.OpenRead(Files.RoseSparkleGIF)) { collection.Read(fs); Assert.AreEqual(3, collection.Count); } collection.Read(Files.RoseSparkleGIF); Assert.AreEqual(3, collection.Count); collection.Dispose(); }