// Support of SoCoResource

    string sourceFileName = "ColorFillLayer.psd";

    string exportPath = "SoCoResource_Edited.psd";

    var im = (PsdImage)Image.Load(sourceFileName);

    using (im)

    {

        foreach (var layer in im.Layers)

        {

            if (layer is FillLayer)

            {

                var fillLayer = (FillLayer)layer;

                foreach (var resource in fillLayer.Resources)

                {

                    if (resource is SoCoResource)

                    {

                        var socoResource = (SoCoResource)resource;

                        Assert.AreEqual(Color.FromArgb(63, 83, 141), socoResource.Color);

                        socoResource.Color = Color.Red;

                        break;

                    }

                 }

                 break;

             }

            im.Save(exportPath);

        }

    }

 // Support of GdFlResource

    string sourceFileName = "ComplexGradientFillLayer.psd";

    string exportPath = "ComplexGradientFillLayer_after.psd";

    var im = (PsdImage)Image.Load(sourceFileName);

    using (im)

    {

        foreach (var layer in im.Layers)

        {

                    if (layer is FillLayer)

                    {

                        var fillLayer = (FillLayer)layer;

                        var resources = fillLayer.Resources;

                        foreach (var res in resources)

                        {

                            if (res is GdFlResource)

                            {

                                // Reading

                                var resource = (GdFlResource)res;

                                if (resource.AlignWithLayer != false ||

                                (Math.Abs(resource.Angle - 45.0) > 0.001) ||

                                resource.Dither != true ||

                                resource.Reverse != false ||

                                resource.Color != Color.Empty ||

                                Math.Abs(resource.HorizontalOffset - (-39)) > 0.001 ||

                                Math.Abs(resource.VerticalOffset - (-5)) > 0.001 ||

                                resource.TransparencyPoints.Length != 3 ||

                                resource.ColorPoints.Length != 2)

                                {

                                    throw new Exception("Resource Parameters were read wrong");

                                }

                                var transparencyPoints = resource.TransparencyPoints;

                                if (Math.Abs(100.0 - transparencyPoints[0].Opacity) > 0.25 ||

                                transparencyPoints[0].Location != 0 ||

                                transparencyPoints[0].MedianPointLocation != 50 ||

                                Math.Abs(50.0 - transparencyPoints[1].Opacity) > 0.25 ||

                                transparencyPoints[1].Location != 2048 ||

                                transparencyPoints[1].MedianPointLocation != 50 ||

                                Math.Abs(100.0 - transparencyPoints[2].Opacity) > 0.25 ||

                                transparencyPoints[2].Location != 4096 ||

                                transparencyPoints[2].MedianPointLocation != 50)

                                {

                                    throw new Exception("Gradient Transparency Points were read Wrong");

                                }

                                var colorPoints = resource.ColorPoints;

                                if (colorPoints[0].Color != Color.FromArgb(203, 64, 140) ||

                                colorPoints[0].Location != 0 ||

                                colorPoints[0].MedianPointLocation != 50 ||

                                colorPoints[1].Color != Color.FromArgb(203, 0, 0) ||

                                colorPoints[1].Location != 4096 ||

                                colorPoints[1].MedianPointLocation != 50)

                                {

                                    throw new Exception("Gradient Color Points were read Wrong");

                                }

                                // Editing

                                resource.Angle = 30.0;

                                resource.Dither = false;

                                resource.AlignWithLayer = true;

                                resource.Reverse = true;

                                resource.HorizontalOffset = 25;

                                resource.VerticalOffset = -15;

                                var newColorPoints = new List<IGradientColorPoint>(resource.ColorPoints);

                                var newTransparencyPoints = new List<IGradientTransparencyPoint>(resource.TransparencyPoints);

                                newColorPoints.Add(new GradientColorPoint()

                                {

                                    Color = Color.Violet,

                                    Location = 4096,

                                    MedianPointLocation = 75

                                });

                                colorPoints[1].Location = 3000;

                                newTransparencyPoints.Add(new GradientTransparencyPoint()

                                {

                                    Opacity = 80.0,

                                    Location = 4096,

                                    MedianPointLocation = 25

                                });

                                transparencyPoints[2].Location = 3000;

                                resource.ColorPoints = newColorPoints.ToArray();

                                resource.TransparencyPoints = newTransparencyPoints.ToArray();

                                im.Save(exportPath);

                            }

                            break;

                        }

                        break;

                    }

                }   

    }

 // Support of VmskResource

        static void ExampleOfVmskResourceSupport()

        {

            string sourceFileName = "Rectangle.psd";

            string exportPath = "Rectangle_changed.psd";

            var im = (PsdImage)Image.Load(sourceFileName);

            using (im)

            {

                var resource = GetVmskResource(im);

                // Reading

                if (resource.IsDisabled != false ||

                    resource.IsInverted != false ||

                    resource.IsNotLinked != false ||

                    resource.Paths.Length != 7 ||

                    resource.Paths[0].Type != VectorPathType.PathFillRuleRecord ||

                    resource.Paths[1].Type != VectorPathType.InitialFillRuleRecord ||

                    resource.Paths[2].Type != VectorPathType.ClosedSubpathLengthRecord ||

                    resource.Paths[3].Type != VectorPathType.ClosedSubpathBezierKnotUnlinked ||

                    resource.Paths[4].Type != VectorPathType.ClosedSubpathBezierKnotUnlinked ||

                    resource.Paths[5].Type != VectorPathType.ClosedSubpathBezierKnotUnlinked||

                    resource.Paths[6].Type != VectorPathType.ClosedSubpathBezierKnotUnlinked)

                {

                        throw new Exception("VmskResource was read wrong");

                }

                var pathFillRule = (PathFillRuleRecord)resource.Paths[0];

                var initialFillRule = (InitialFillRuleRecord)resource.Paths[1];

                var subpathLength = (LengthRecord)resource.Paths[2];

                // Path fill rule doesn't contain any additional information

                if (pathFillRule.Type != VectorPathType.PathFillRuleRecord ||

                initialFillRule.Type != VectorPathType.InitialFillRuleRecord ||

                initialFillRule.IsFillStartsWithAllPixels != false ||

                subpathLength.Type != VectorPathType.ClosedSubpathLengthRecord ||

                subpathLength.IsClosed != true ||

                subpathLength.IsOpen != false)

                {

                    throw new Exception("VmskResource paths were read wrong");

                }

                // Editing

                resource.IsDisabled = true;

                resource.IsInverted = true;

                resource.IsNotLinked = true;

                var bezierKnot = (BezierKnotRecord)resource.Paths[3];

                bezierKnot.Points[0] = new Point(0, 0);

                bezierKnot = (BezierKnotRecord)resource.Paths[4];

                bezierKnot.Points[0] = new Point(8039797, 10905190);

                initialFillRule.IsFillStartsWithAllPixels = true;

                subpathLength.IsClosed = false;

                im.Save(exportPath);

            }         

        }

        static VmskResource GetVmskResource(PsdImage image)

        {

            var layer = image.Layers[1];

            VmskResource resource = null;

            var resources = layer.Resources;

            for (int i = 0; i < resources.Length; i++)

            {

                if (resources[i] is VmskResource)

                {

                    resource = (VmskResource) resources[i];

                    break;

                }

            }

            if (resource == null)

            {

                throw new Exception("VmskResource not found");

            }

            return resource;

        }   

 // Add support of Fill layers: Color fill

    string sourceFileName = "ColorFillLayer.psd";

    string exportPath = "ColorFillLayer_output.psd";

    string exportPathPng = "ColorFillLayer_output.png";

    var im = (PsdImage)Image.Load(sourceFileName);

    using (im)

    {

        foreach (var layer in im.Layers)

        {

            if (layer is FillLayer)

            {

                var fillLayer = (FillLayer)layer;

                if (fillLayer.FillSettings.FillType != FillType.Color)

                {

                    throw new Exception("Wrong Fill Layer");

                }

                var settings = (IColorFillSettings)fillLayer.FillSettings;

                settings.Color = Color.Red;    

                fillLayer.Update();

                im.Save(exportPath);

                break;

            }

        }

    }

 // Support of Gradient Fill Layer

    string sourceFileName = "ComplexGradientFillLayer.psd";

    string outputFile = "ComplexGradientFillLayer_output.psd";

    var im = (PsdImage)Image.Load(sourceFileName);

    using (im)

            {

                foreach (var layer in im.Layers)

                {

                    if (layer is FillLayer)

                    {

                        var fillLayer = (FillLayer)layer;

                        if (fillLayer.FillSettings.FillType != FillType.Gradient)

                        {

                            throw new Exception("Wrong Fill Layer");

                        }

                        var settings = (IGradientFillSettings)fillLayer.FillSettings;

                        if (

                            Math.Abs(settings.Angle - 45) > 0.25 ||

                            settings.Dither != true ||

                            settings.AlignWithLayer != false ||

                            settings.Reverse != false ||

                            Math.Abs(settings.HorizontalOffset - (-39)) > 0.25 ||

                            Math.Abs(settings.VerticalOffset - (-5)) > 0.25 ||

                            settings.TransparencyPoints.Length != 3 ||

                            settings.ColorPoints.Length != 2 ||

                            Math.Abs(100.0 - settings.TransparencyPoints[0].Opacity) > 0.25 ||

                            settings.TransparencyPoints[0].Location != 0 ||

                            settings.TransparencyPoints[0].MedianPointLocation != 50 ||

                            settings.ColorPoints[0].Color != Color.FromArgb(203, 64, 140) ||

                            settings.ColorPoints[0].Location != 0 ||

                            settings.ColorPoints[0].MedianPointLocation != 50)

                        {

                            throw new Exception("Gradient Fill was not read correctly");

                        }

                        settings.Angle = 0.0;

                        settings.Dither = false;

                        settings.AlignWithLayer = true;

                        settings.Reverse = true;

                        settings.HorizontalOffset = 25;

                        settings.VerticalOffset = -15;

                        var colorPoints = new List<IGradientColorPoint>(settings.ColorPoints);

                        var transparencyPoints = new List<IGradientTransparencyPoint>(settings.TransparencyPoints);

                        colorPoints.Add(new GradientColorPoint()

                        {

                            Color = Color.Violet,

                            Location = 4096,

                            MedianPointLocation = 75

                        });

                        colorPoints[1].Location = 3000;

                        transparencyPoints.Add(new GradientTransparencyPoint()

                        {

                            Opacity = 80.0,

                            Location = 4096,

                            MedianPointLocation = 25

                        });

                        transparencyPoints[2].Location = 3000;

                        settings.ColorPoints = colorPoints.ToArray();

                        settings.TransparencyPoints = transparencyPoints.ToArray();

                        fillLayer.Update();

                        im.Save(outputFile, new PsdOptions(im));

                        break;

                    }

                }

            }

 // Rendering of rotated by TransformMatrix Text Layers

      string sourceFileName = "TransformedText.psd";

      string exportPath = "TransformedTextExport.psd";

      string exportPathPng = "TransformedTextExport.png";

      var im = (PsdImage)Image.Load(sourceFileName);

      using (im)

      {

         im.Save(exportPath);

         im.Save(exportPathPng, new PngOptions() { ColorType = PngColorType.TruecolorWithAlpha });

      }

 string dir = "c:\\aspose.work\\IMAGINGNET\\3351\\";

using (Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = (Aspose.Imaging.FileFormats.Tiff.TiffImage)Image.Load(dir + "source2.tif"))

{

    int i = 0;

    foreach (Aspose.Imaging.FileFormats.Tiff.TiffFrame tiffFrame in tiffImage.Frames)

    {

        Aspose.Imaging.ImageOptions.JpegOptions saveOptions = new Aspose.Imaging.ImageOptions.JpegOptions();

        saveOptions.ResolutionSettings = new ResolutionSetting(tiffFrame.HorizontalResolution, tiffFrame.VerticalResolution);

        if (tiffFrame.FrameOptions != null)

        {

            // Set the resolution unit explicitly.

            switch (tiffFrame.FrameOptions.ResolutionUnit)

            {

                case Aspose.Imaging.FileFormats.Tiff.Enums.TiffResolutionUnits.None:

                    saveOptions.ResolutionUnit = ResolutionUnit.None;

                    break;

                case Aspose.Imaging.FileFormats.Tiff.Enums.TiffResolutionUnits.Inch:

                    saveOptions.ResolutionUnit = ResolutionUnit.Inch;

                    break;

                case Aspose.Imaging.FileFormats.Tiff.Enums.TiffResolutionUnits.Centimeter:

                    saveOptions.ResolutionUnit = ResolutionUnit.Cm;

                    break;

                default:

                    throw new System.NotSupportedException();

            }

        }

        string fileName = "source2.tif.frame." + (i++) + "." + saveOptions.ResolutionUnit + ".jpg";

        tiffFrame.Save(dir + fileName, saveOptions);

    }

}

 using (Image image = Image.Load("halfGigImage.png")) {

    // todo something

}

 string dir = "c:\\aspose.work\\IMAGINGNET\\3287\\";

string fileName = dir + "image2.wmf";

// Save WMF to SVG

using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(fileName))

{

    // The customer uses EmfRasterizationOptions instead of WmfRasterizationOptions.

    // EmfRasterizationOptions works correctly in .NET as well.

    Aspose.Imaging.ImageOptions.WmfRasterizationOptions rasterizationOptions = new Aspose.Imaging.ImageOptions.WmfRasterizationOptions();

    rasterizationOptions.PageSize = image.Size;

    Aspose.Imaging.ImageOptions.SvgOptions saveOptions = new Aspose.Imaging.ImageOptions.SvgOptions();

    saveOptions.VectorRasterizationOptions = rasterizationOptions;

    image.Save(fileName + ".svg", saveOptions);

}                

// Save WMF to PNG

using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(fileName))

{

    // The customer uses EmfRasterizationOptions instead of WmfRasterizationOptions.

    // EmfRasterizationOptions works correctly in .NET as well.

    Aspose.Imaging.ImageOptions.WmfRasterizationOptions rasterizationOptions = new Aspose.Imaging.ImageOptions.WmfRasterizationOptions();

    rasterizationOptions.PageSize = image.Size;

    Aspose.Imaging.ImageOptions.PngOptions saveOptions = new Aspose.Imaging.ImageOptions.PngOptions();

    saveOptions.VectorRasterizationOptions = rasterizationOptions;

    image.Save(fileName + ".png", saveOptions);

}

 public void WmfToJpg()

{

    using (Image image = Image.Load("portrt.wmf")) {

        image.Save(

                    "portrt.jpg",

                    new JpegOptions()

                        {

                            VectorRasterizationOptions = new WmfRasterizationOptions

                                                             {

                                                                 BackgroundColor = Color.WhiteSmoke,

                                                                 PageWidth = image.Width,

                                                                 PageHeight = image.Height,

                                                             }

                        });

    }

}

public void WmfToPngWithBorders()

{

    using (Image image = Image.Load("portrt.wmf")) {

        image.Save(

                    "portrt.png",

                    new PngOptions()

                        {

                            VectorRasterizationOptions = new WmfRasterizationOptions

                                                             {

                                                                 BackgroundColor = Color.WhiteSmoke,

                                                                 PageWidth = image.Width,

                                                                 PageHeight = image.Height,

                                                                 BorderX = 50,

                                                                 BorderY = 20

                                                             }

                        });

    }

}

 string fileName = "example.odg";

using (OdgImage image = (OdgImage)Image.Load(fileName))

{

}

 public void TestExportGifToPdf()

{

    string[] fileNames = new [] {

        "czone.gif",

        "DTRA_LogoType.gif",

        "DTRA_Seal.gif",

        "Equip1.gif",

        "Equip2.gif",

        "Equip3.gif"

    };

    foreach (string fileName in fileNames) {

        using (Image image = Image.Load(fileName))

        {

            image.Save(fileName + ".pdf", new PdfOptions());

        }

    }

}

 // RotateFlip operation doesn't work as expected with PSD

            string sourceFile = "1.psd";

            string pngPath = "RotateFlipTest2617.png";

            string psdPath = "RotateFlipTest2617.psd";

            RotateFlipType flipType = RotateFlipType.Rotate270FlipXY;

            using (var im = (PsdImage)(Image.Load(sourceFile)))

            {

                im.RotateFlip(flipType);

                im.Save(pngPath, new PngOptions() { ColorType = PngColorType.TruecolorWithAlpha });

                im.Save(psdPath);

            }

  using (DjvuImage image = (DjvuImage)Imaging.Image.Load(@"input.djvu"))

{

    PngOptions exportOptions = new PngOptions();

    for (int i = 0; i < image.Pages.Length; i++)

    {

        DjvuPage page = image.Pages[i];

        page.Save(@"page" + i + ".png", exportOptions);

    }

}

 using (Image image = Image.Load("test.svg"))

{

    image.Save("test.svg_out.bmp",

        new BmpOptions()

        {

            VectorRasterizationOptions = new SvgRasterizationOptions()

            {

                PageWidth = 100,

                PageHeight = 200

            }

         });

}

 using (EmfImage image = Image.Load("test.emf") as EmfImage)

{

    image.Crop(new Rectangle(10, 10, 100, 150));

    Console.WriteLine(image.Width);

    Console.WriteLine(image.Height);

    image.Save("test.emf_crop.emf");

}

using (WmfImage image = Image.Load("test.wmf") as WmfImage)

{

    image.Crop(new Rectangle(10, 10, 100, 150));

    Console.WriteLine(image.Width);

    Console.WriteLine(image.Height);

    image.Save("test.wmf_crop.wmf");

}

 Please use the following code to draw a raster image on Wmf image:

string dir = "c:\\aspose.work\\IMAGINGNET\\3346\\";

// Load the image to be drawn

using (RasterImage imageToDraw = (RasterImage)Image.Load(dir + "asposenet_220_src01.png"))

{

    // Load the image for drawing on it (drawing surface)

    using (WmfImage canvasImage = (WmfImage)Image.Load(dir + "asposenet_222_wmf_200.wmf"))

    {

        WmfRecorderGraphics2D graphics = WmfRecorderGraphics2D.FromWmfImage(canvasImage);

        // Draw a rectagular part of the raster image within the specified bounds of the vector image (drawing surface).

        // Note that because the source size is not equal to the destination one, the drawn image is stretched horizontally and vertically.

        graphics.DrawImage(

            imageToDraw,

            new Rectangle(67, 67, canvasImage.Width, canvasImage.Height),

            new Rectangle(0, 0, imageToDraw.Width, imageToDraw.Height),

            GraphicsUnit.Pixel);

        // Save the result image

        using (WmfImage resultImage = graphics.EndRecording())

        {

            resultImage.Save(dir + "asposenet_222_wmf_200.DrawImage.wmf");

        }

    }

}

 Please use the following code to draw a raster image on Emf image:

string dir = "c:\\aspose.work\\IMAGINGNET\\3346\\";

// Load the image to be drawn

using (RasterImage imageToDraw = (RasterImage)Image.Load(dir + "asposenet_220_src01.png"))

{

    // Load the image for drawing on it (drawing surface)

    using (EmfImage canvasImage = (EmfImage)Image.Load(dir + "input.emf"))

    {

        EmfRecorderGraphics2D graphics = EmfRecorderGraphics2D.FromEmfImage(canvasImage);

        // Draw a rectagular part of the raster image within the specified bounds of the vector image (drawing surface).

        // Note that because the source size is not equal to the destination one, the drawn image is stretched horizontally and vertically.

        graphics.DrawImage(

            imageToDraw,

            new Rectangle(67, 67, canvasImage.Width, canvasImage.Height),

            new Rectangle(0, 0, imageToDraw.Width, imageToDraw.Height),

            GraphicsUnit.Pixel);

        // Save the result image

        using (EmfImage resultImage = graphics.EndRecording())

        {

            resultImage.Save(dir + "input.DrawImage.emf");

        }

    }

}

 Please use the following code to draw a raster image on Svg image:

string dir = "c:\\aspose.work\\IMAGINGNET\\3346\\";

// Load the image to be drawn

using (RasterImage imageToDraw = (RasterImage)Image.Load(dir + "asposenet_220_src01.png"))

{

    // Load the image for drawing on it (drawing surface)

    using (SvgImage canvasImage = (SvgImage)Image.Load(dir + "asposenet_220_src02.svg"))

    {

        // Drawing on an existing Svg image.

        Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D graphics = new Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D(canvasImage);

        // Draw a rectagular part of the raster image within the specified bounds of the vector image (drawing surface).

        // Note that because the source size is equal to the destination one, the drawn image is not stretched.

        graphics.DrawImage(                        

            new Rectangle(0, 0, imageToDraw.Width, imageToDraw.Height),

            new Rectangle(67, 67, imageToDraw.Width, imageToDraw.Height),

            imageToDraw);

        // Save the result image

        using (SvgImage resultImage = graphics.EndRecording())

        {

            resultImage.Save(dir + "asposenet_220_src02.DrawImage.svg");

        }

    }

}

 Note that drawing a vector image is not supported at now. It needs to convert the drawn vector image to a raster before drawing as shown below:

// The following code shows how to draw a vector image on another vector image.

// For example let's draw an Svg image over itself with optional scaling.

string dir = "c:\\aspose.work\\IMAGINGNET\\3346\\";

using (MemoryStream drawnImageStream = new MemoryStream())

{

    // First, rasterize Svg to Png and write the result to a stream.

    using (SvgImage svgImage = (SvgImage)Image.Load(dir + "asposenet_220_src02.svg"))

    {

        SvgRasterizationOptions rasterizationOptions = new SvgRasterizationOptions();

        rasterizationOptions.PageSize = svgImage.Size;

        PngOptions saveOptions = new PngOptions();

        saveOptions.VectorRasterizationOptions = rasterizationOptions;

        svgImage.Save(drawnImageStream, saveOptions);

        // Now load a Png image from stream for further drawing.

        drawnImageStream.Seek(0, SeekOrigin.Begin);

        using (RasterImage imageToDraw = (RasterImage)Image.Load(drawnImageStream))

        {   

            // Drawing on the existing Svg image.

            Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D graphics = new Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D(svgImage);

            // Scale down the entire drawn image by 2 times and draw it to the center of the drawing surface.

            int width = imageToDraw.Width / 2;

            int height = imageToDraw.Height / 2;

            Point origin = new Point((svgImage.Width - width) / 2, (svgImage.Height - height) / 2);

            Size size = new Size(width, height);

            graphics.DrawImage(imageToDraw, origin, size);

            // Save the result image

            using (SvgImage resultImage = graphics.EndRecording())

            {

                resultImage.Save(dir + "asposenet_220_src02.DrawVectorImage.svg");

            }

        }

    }

}

 using (Image image = Image.Load("1.emf"))

{

    image.Save("out.emf");

}

 string psdFileName = ("asposenet_230_src_psd.psd");

string drwFileName = ("asposenet_230_200psd.psd");

string psdFileNameOutput = ("asposenet_230_output_psd.psd");

            using (Aspose.Imaging.Image canvasImagePsd = Aspose.Imaging.Image.Load(psdFileName))

            {

                using (Aspose.Imaging.Image imageToDrawPng = Aspose.Imaging.Image.Load(drwFileName))

                {

                    Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(canvasImagePsd);

                    Aspose.Imaging.Rectangle signRect = new Aspose.Imaging.Rectangle(0, 0, 200, 200);

                    graphics.DrawImage(imageToDrawPng, new Aspose.Imaging.Point(signRect.X, signRect.Y));

                    canvasImagePsd.Save(psdFileNameOutput);

                }

            }

 public void TestParallel()

{

    string fileName = "test1.djvu";

    int numThreads = 20;

    var tasks = Enumerable.Range(1, numThreads).Select(

        taskNum =>

            {

                var inputFile = this.GetFileInBaseFolder(fileName);

                var outputFile = this.GetFileInOutputFolder($"{fileName}_task{taskNum}.png");

                return Task.Run(

                    () =>

                        {

                            using (FileStream fs = File.OpenRead(inputFile))

                            {

                                using (Image image = Image.Load(fs))

                                {

                                    image.Save(outputFile, new PngOptions());

                                }

                            }

                        });

            });

    Task.WaitAll(tasks.ToArray());

}

 string sourceFIle = @"grinched-regular-font.psd";

FontSettings.SetFontsFolder(@"c://Font");

FontSettings.UpdateFonts();

using (PsdImage image = (PsdImage)Image.Load(sourceFIle, new PsdLoadOptions()))

{

image.Save("result.png", new PngOptions());

}

FontSettings.Reset();

FontSettings.UpdateFonts();

using (PsdImage image = (PsdImage)Image.Load(sourceFIle, new PsdLoadOptions()))

{

image.Save("result2.png", new PngOptions());

}

 using (Image image = Image.Load("importimage2.wmf"))

{

    image.Save(

        "importimage2.png",

        new PngOptions()

            {

                VectorRasterizationOptions = new WmfRasterizationOptions()

                                                 {

                                                     BackgroundColor = Color.WhiteSmoke,

                                                     PageWidth = image.Width,

                                                     PageHeight = image.Height

                                                 }

            });

}

 string baseFolder = "D:";

            string fileName = "image7.emf";

            string inputFileName = Path.Combine(baseFolder, fileName);

            string outputFileName = inputFileName + ".svg";

            using (Image image = Image.Load(inputFileName))

            {

                image.Save(outputFileName, new SvgOptions(){VectorRasterizationOptions = new EmfRasterizationOptions(){PageSize = image.Size}});

            }

 protected string TestDirectory => "Custom";

private readonly List<Tuple<ImageOptionsBase, string>> imageSaveData = new List<Tuple<ImageOptionsBase, string>>()

{

    new Tuple<ImageOptionsBase, string>(new BmpOptions(), ".bmp"),

    new Tuple<ImageOptionsBase, string>(new PngOptions(), ".png"),

    new Tuple<ImageOptionsBase, string>(new JpegOptions(), ".jpg"),

    new Tuple<ImageOptionsBase, string>(new WebPOptions(), ".webp"),

    new Tuple<ImageOptionsBase, string>(new GifOptions(), ".gif"),

    new Tuple<ImageOptionsBase, string>(new TiffOptions(TiffExpectedFormat.Default), ".tiff"),

    new Tuple<ImageOptionsBase, string>(new PsdOptions(), ".psd")

};

public async Task TestDjvuExportParallel()

{

    var tasks = imageSaveData.Select(t => SaveAsAsync("test1.djvu", t.Item1, t.Item2)).ToList();

    tasks.AddRange(imageSaveData.Select(t => SaveAsAsync("test2.djvu", t.Item1, t.Item2)));

    await Task.WhenAll(tasks);

}

public void TestDjvuExportOrdered()

{

    foreach(var tuple in imageSaveData)

    {

        this.SaveAs("test1.djvu", false, tuple.Item1, tuple.Item2);

        this.SaveAs("test2.djvu", false, tuple.Item1, tuple.Item2);

    }

}

public void TestMultiPageExport()

{

    this.SaveAs("test1.djvu", false, new TiffOptions(TiffExpectedFormat.Default) { MultiPageOptions = new DjvuMultiPageOptions() }, ".tiff");

}

private async Task SaveAsAsync(string fileName, ImageOptionsBase optionsBase, string extension)

{

    await Task.Run(() =>

    {

        this.SaveAs(fileName, true, optionsBase, extension);

    });

}

private void SaveAs(string fileName, bool parallel, ImageOptionsBase optionsBase, string extension)

{

    using (FileStream fs = File.OpenRead(Path.Combine(this.TestDirectory, fileName)))

    {

        using (var image = Image.Load(fs) as RasterImage)

        {

            image.Save(Path.Combine(this.TestDirectory, $"{fileName}_{ (parallel ? "parallel" : "ordered") }{extension}"),

                optionsBase);

        }

    }

}

 Rectangle rect = new Rectangle(100, 100, 100, 150);

            string baseFolder = "D:";

            string inputFileName = Path.Combine(baseFolder, "test.webp");

            string outputFileName = Path.Combine(baseFolder, "test_out.webp");

            string outputFileNameCached = Path.Combine(baseFolder, "test_out_cache.webp");

            //crop & save

            using (RasterImage image = (RasterImage)Image.Load(inputFileName))

            {

                image.Crop(rect);

                image.Save(outputFileName);

            }

            //crop & save with cache

            using (RasterImage image = (RasterImage)Image.Load(inputFileName))

            {

                image.CacheData();

                image.Crop(rect);

                image.Save(outputFileNameCached);

            }

            //compare files

            using (FileStream fs = new FileStream(outputFileName, FileMode.Open))

            using (FileStream fs1 = new FileStream(outputFileNameCached, FileMode.Open))

            {

                Assert.AreEqual(fs.Length, fs1.Length, "Length of files not equal");

                for (int i = 0; i < fs.Length; i++)

                {

                    int aByte = fs.ReadByte();

                    int bByte = fs1.ReadByte();

                    if (aByte.CompareTo(bByte) != 0)

                    {

                        throw new Exception("Files not equal");

                    }

                }

            }

 string baseFolder = "D:";

string inputFile = Path.Combine(baseFolder, "Animation1.webp");

string outputFile = Path.Combine(baseFolder, "Animation2.webp");

using (MemoryStream ms = new MemoryStream())

{

  using (WebPImage image = (WebPImage)Image.Load(inputFile))

  {

    image.Resize(300, 450, ResizeType.HighQualityResample);

    image.Crop(new Rectangle(10, 10, 200, 300));

    image.RotateFlipAll(RotateFlipType.Rotate90FlipX);

    image.Save(ms);

  }

  using (FileStream fs = new FileStream(outputFile, FileMode.Create))

  {

    fs.Write(ms.GetBuffer(), 0, (int)ms.Length);

  }

}