Aspose.Imaging for .NET 20.12 - Release notes

### Creating new Tga image with a centered red circle

var options = new TgaOptions
                  {
                      Source = new FileCreateSource("output.tga", false)
                  };

using (var image = Image.Create(options, 1000, 1000))
{
    var graphics = new Graphics(image);
    graphics.FillEllipse(new SolidBrush(Color.Red), 300, 300, 400, 400);
    image.Save();
}

GraphCutHelper async operations
Test that all types of masking operations (ImageMasking.Decompose, ImageMasking.DecomposeAsync,
IMaskingSession.Decompose, IMaskingSession.DecomposeAsync) produce the same result.


string inputFilePath = "fileName";
string outputFilePath1 = "outputfileName_1.png";
string outputFilePath2 = "outputfileName_2.png";
string outputFilePath3 = "outputfileName_3.png";
string outputFilePath4 = "outputfileName_4.png";
string tempFilePath = outputFilePath1 + "_temp";

using (RasterImage image = (RasterImage)Image.Load(inputFilePath))
{
    int featheringRadius = (Math.Max(image.Width, image.Height) / 500) + 1;
    AutoMaskingGraphCutOptions options = new AutoMaskingGraphCutOptions
    {
        AssumedObjects = null,
        CalculateDefaultStrokes = true,
        FeatheringRadius = featheringRadius,
        Method = SegmentationMethod.GraphCut,
        Decompose = false,
        ExportOptions =
            new PngOptions()
            {
                ColorType = PngColorType.TruecolorWithAlpha,
                Source = new FileCreateSource(tempFilePath)
            },
        BackgroundReplacementColor = Color.Transparent,
    };

    using (MaskingResult results = new ImageMasking(image).Decompose(options))
    {
        using (RasterImage resultImage = (RasterImage)results[1].GetImage())
        {
            resultImage.Save(outputFilePath1,
		new PngOptions() { ColorType = PngColorType.TruecolorWithAlpha });
        }
    }
}

using (RasterImage image = (RasterImage)Image.Load(inputFilePath))
{
    int featheringRadius = (Math.Max(image.Width, image.Height) / 500) + 1;
    AutoMaskingGraphCutOptions options = new AutoMaskingGraphCutOptions
    {
        AssumedObjects = null,
        CalculateDefaultStrokes = true,
        FeatheringRadius = featheringRadius,
        Method = SegmentationMethod.GraphCut,
        Decompose = false,
        ExportOptions =
            new PngOptions()
            {
                ColorType = PngColorType.TruecolorWithAlpha,
                Source = new FileCreateSource(tempFilePath)
            },
        BackgroundReplacementColor = Color.Transparent,
    };

    IAsyncTask asyncTask = new ImageMasking(image).DecomposeAsync(options);
    asyncTask.RunAsync();
    asyncTask.AsyncWaitHandle.WaitOne();
    using (MaskingResult results = (MaskingResult)asyncTask.Result)
    {
        using (RasterImage resultImage = (RasterImage)results[1].GetImage())
        {
            resultImage.Save(outputFilePath2,
		new PngOptions() { ColorType = PngColorType.TruecolorWithAlpha });
        }
    }
}

using (RasterImage image = (RasterImage)Image.Load(inputFilePath))
{
    int featheringRadius = (Math.Max(image.Width, image.Height) / 500) + 1;
    AutoMaskingGraphCutOptions options = new AutoMaskingGraphCutOptions
    {
        AssumedObjects = null,
        CalculateDefaultStrokes = true,
        FeatheringRadius = featheringRadius,
        Method = SegmentationMethod.GraphCut,
        Decompose = false,
        ExportOptions =
            new PngOptions()
            {
                ColorType = PngColorType.TruecolorWithAlpha,
                Source = new FileCreateSource(tempFilePath)
            },
        BackgroundReplacementColor = Color.Transparent,
    };

    using (IMaskingSession maskingSession = new ImageMasking(image).CreateSession(options))
    {
        using (MaskingResult results = maskingSession.Decompose())
        {
            using (RasterImage resultImage = (RasterImage)results[1].GetImage())
            {
                resultImage.Save(outputFilePath3,
                   new PngOptions() { ColorType = PngColorType.TruecolorWithAlpha });
            }
        }
    }
}

using (RasterImage image = (RasterImage)Image.Load(inputFilePath))
{
    int featheringRadius = (Math.Max(image.Width, image.Height) / 500) + 1;
    AutoMaskingGraphCutOptions options = new AutoMaskingGraphCutOptions
    {
        AssumedObjects = null,
        CalculateDefaultStrokes = true,
        FeatheringRadius = featheringRadius,
        Method = SegmentationMethod.GraphCut,
        Decompose = false,
        ExportOptions =
            new PngOptions()
            {
                ColorType = PngColorType.TruecolorWithAlpha,
                Source = new FileCreateSource(tempFilePath)
            },
        BackgroundReplacementColor = Color.Transparent,
    };

    using (IMaskingSession maskingSession = new ImageMasking(image).CreateSession(options))
    {
        IAsyncTask asyncTask = maskingSession.DecomposeAsync();
        asyncTask.RunAsync();
        asyncTask.AsyncWaitHandle.WaitOne();
        using (MaskingResult results = (MaskingResult)asyncTask.Result)
        {
            using (RasterImage resultImage = (RasterImage)results[1].GetImage())
            {
                resultImage.Save(outputFilePath4,
                        new PngOptions() { ColorType = PngColorType.TruecolorWithAlpha });
            }
        }
    }
}

// All result images should be identical.


GraphCutHelper progress reporting
Test GraphCutHelper progress reporting support.


StringBuilder eventLog = new StringBuilder();
ProgressEventHandler eventHandler = delegate(ProgressEventHandlerInfo info)
{
    eventLog.AppendLine(string.Format("{0} / {1} : {2}",
         info.Value, info.MaxValue, info.EventType));
};

string inputFilePath = "fileName";
string outputFilePath = "outputfileName.png";

using (RasterImage image = (RasterImage) Image.Load(inputFilePath))
{
    int featheringRadius = (Math.Max(image.Width, image.Height) / 500) + 1;
    AutoMaskingGraphCutOptions options = new AutoMaskingGraphCutOptions
    {
        AssumedObjects = null,
        CalculateDefaultStrokes = true,
        FeatheringRadius = featheringRadius,
        PrecalculationProgressEventHandler = eventHandler,
        Method = SegmentationMethod.GraphCut,
        Decompose = false,
        ExportOptions =
            new PngOptions()
            {
                ColorType = PngColorType.TruecolorWithAlpha,
                Source = new FileCreateSource(outputFilePath + "_temp")
            },
        BackgroundReplacementColor = Color.Transparent,
    };

    IAsyncTask asyncTask = new ImageMasking(image).DecomposeAsync(options);
    asyncTask.RunAsync();
    asyncTask.AsyncWaitHandle.WaitOne();
    using (MaskingResult results = (MaskingResult) asyncTask.Result)
    {
        using (RasterImage resultImage = (RasterImage) results[1].GetImage())
        {
            resultImage.Save(outputFilePath,
                new PngOptions() {ColorType = PngColorType.TruecolorWithAlpha});
        }
    }
}

bool isProgressLogged = eventLog.ToString() == "1 / 1 : Initialization\r\n" +
    "2 / 3 : PreProcessing\r\n" +
    "3 / 3 : Processing\r\n" +
    "4 / 9 : RelativeProgress\r\n" +
    "5 / 9 : RelativeProgress\r\n" +
    "6 / 9 : RelativeProgress\r\n" +
    "7 / 9 : RelativeProgress\r\n" +
    "8 / 9 : RelativeProgress\r\n" +
    "9 / 9 : Finalization\r\n";


GraphCutHelper with OrphanedPoints specified
Test that OrphanedPoints specification in the
AutoMaskingGraphCutOptions does have an effect on the masking result in a MaskingSession.


string inputFilePath = "Gorilla.bmp";
string tempFilePath = "temp.png";
string initialOutputFilePath = "initialOutput.png";
string improvedOutputFilePath = "improvedOutput.png";

using (RasterImage image = (RasterImage)Image.Load(inputFilePath))
{
    AutoMaskingGraphCutOptions maskingOptions = new AutoMaskingGraphCutOptions()
    {
        Method = SegmentationMethod.GraphCut,
        Args = new AutoMaskingArgs
        {
            ObjectsRectangles =
                new Rectangle[]
                {
                    new Rectangle(86, 6, 270, 364),
                }
        },
        Decompose = false,
        ExportOptions =
            new PngOptions()
            {
                Source = new FileCreateSource(tempFilePath)
            },
        BackgroundReplacementColor = Color.Orange,
        CalculateDefaultStrokes = true,
        FeatheringRadius = 2
    };

    using (IMaskingSession maskingSession =
       new ImageMasking(image).CreateSession(maskingOptions))
    {
        MaskingResult maskingResult = maskingSession.Decompose();

        using (RasterImage resultImage = (RasterImage)maskingResult[1].GetImage())
        {
            resultImage.Save(initialOutputFilePath,
		new PngOptions() { ColorType = PngColorType.TruecolorWithAlpha });
        }

        // At this point initial masking results can be viewed and analyzed.
        // Orphaned points should be from the foreground/background points
        // or areas where foreground/background points are supposed to be.
        var orphanedPoints = new List<Point>();
        orphanedPoints.AddRange(GetRectanglePoints(new Rectangle[]
        {
            new Rectangle(0, 0, 200, 300),
        }));
        orphanedPoints.AddRange(maskingOptions.DefaultForegroundStrokes);
        orphanedPoints.AddRange(maskingOptions.DefaultBackgroundStrokes);
        maskingResult = maskingSession.ImproveDecomposition(new AutoMaskingArgs()
        {
            OrphanedPoints = orphanedPoints.ToArray()
        });

        using (RasterImage resultImage = (RasterImage)maskingResult[1].GetImage())
        {
            resultImage.Save(improvedOutputFilePath,
 		new PngOptions() { ColorType = PngColorType.TruecolorWithAlpha });
        }

        // At this point we can check that the result image has changed.
    }
}



// Return all points that belongs to the specified rectangles.
Point[] GetRectanglePoints(params Rectangle[] rectangles)
{
    int arraySize = 0;
    foreach (Rectangle rectangle in rectangles)
    {
        arraySize += rectangle.Width * rectangle.Height;
    }

    Point[] pointArray = new Point[arraySize];
    int arrayIndex = 0;
    foreach (Rectangle rectangle in rectangles)
    {
        for (int x = rectangle.Left; x < rectangle.Right; x++)
        {
            for (int y = rectangle.Top; y < rectangle.Bottom; y++)
            {
                pointArray[arrayIndex++] = new Point(x, y);
            }
        }
    }

    return pointArray;
}

using (var image = Image.Load(folder + "Sample.bmp"))
{
     if (image.UsePalette)
     {
          Console.WriteLine("The palette is used by the image");
     }
}

using (var image = Image.Load("LetterHeadWW.emf"))
{
    image.Save("result.png", new PngOptions());
}

Receiving a detailed error message loading corrupted image



try
{
    using (var image = Image.Load("design.bmp"))
    {
        PngOptions pngOptions = new PngOptions();
        image.Save("output.png", pngOptions);
    }
}
catch (ImageSaveException e)
{
    bool hasExpectedExceptionMessage = e.InnerException.InnerException.Message
	== "Required palette is missing. Image data loading failed.";
    if (!hasExpectedExceptionMessage)
    {
        throw;
    }
}

### Cropping a TGA image


            using (RasterImage sampleTgaImage = (RasterImage)Image.Load("test.tga"))
            {
                sampleTgaImage.Crop(10, 10, 10, 10);
                sampleTgaImage.Save("crop.tga");
            }


### Rotating a TGA image


            using (RasterImage sampleTgaImage = (RasterImage)Image.Load("test.tga"))
            {
                sampleTgaImage.Rotate(30);
                sampleTgaImage.Save("rotate.tga");
            }


### Resizing a TGA image


            using (RasterImage sampleTgaImage = (RasterImage)Image.Load("test.tga"))
            {
                sampleTgaImage.Resize(100, 100);
                sampleTgaImage.Save("resize.tga");
            }


### Flip-rotating a TGA image


            using (RasterImage sampleTgaImage = (RasterImage)Image.Load("test.tga"))
            {
                sampleTgaImage.RotateFlip(RotateFlipType.Rotate270FlipXY);
                sampleTgaImage.Save("rotate_flip.tga");
            }

using (var page1 = (TiffImage)Image.Load("Image1.tif"))
{
    using (var page2 = (TiffImage)Image.Load("Image2.tif"))
    {
        page1.AddFrame(TiffFrame.CopyFrame(page2.ActiveFrame));
    }

    page1.Save("Result.tif");
}

string baseFolder = Path.Combine(@"D:\", "test");
string outFileName = "MultipageImageCreateTest.tif";
string outputFilePath = Path.Combine(baseFolder, outFileName);
string[] files = new string[]{ "33266.tif", "Animation.gif", "elephant.png", "Input.jp2",
				"eye.wmf", "tiger.bmp", "MultiPage.cdr", "juanmontoya_lingerie.svg" };
List<Image> images = new List<Image>();
foreach (var file in files)
{
   string filePath = Path.Combine(baseFolder, file);
   images.Add(Image.Load(filePath));
}

using (Image image = Image.Create(images.ToArray(), true))
{
   image.Save(outputFilePath, new TiffOptions(TiffExpectedFormat.TiffJpegRgb));
}

using (var image = (JpegImage)Image.Load("Sample.jpg"))
{
    foreach (var makerNote in image.ExifData.MakerNotes)
    {
        Console.WriteLine("{0}: {1}", makerNote.Name, makerNote.Value);
    }

    Console.ReadKey();
}

using (var page1 = (TiffImage)Image.Load("Image1.tif"))
{
    using (var page2 = (TiffImage)Image.Load("Image2.tif"))
    {
        page1.AddFrame(TiffFrame.CopyFrame(page2.ActiveFrame));
    }

    page1.Save("Result.tif");
}

string baseFolder = Path.Combine(@"D:\", "test");
string outFileName = "MultipageImageCreateTest.tif";
string outputFilePath = Path.Combine(baseFolder, outFileName);
string[] files = new string[]{ "33266.tif", "Animation.gif", "elephant.png", "Input.jp2",
                               "eye.wmf", "tiger.bmp", "MultiPage.cdr", "juanmontoya_lingerie.svg" };
List<Image> images = new List<Image>();
foreach (var file in files)
{
   string filePath = Path.Combine(baseFolder, file);
   images.Add(Image.Load(filePath));
}

using (Image image = Image.Create(images.ToArray(), true))
{
   image.Save(outputFilePath, new TiffOptions(TiffExpectedFormat.TiffJpegRgb));
}