What's New in Aspose.Imaging for .NET

This page highlights the new features and enhancements introduced in recent releases of Aspose.Imaging graphic library. Your feedback is invaluable to us as we strive to improve our product. We greatly appreciate it if you take a moment to provide your insights on different aspects and complete the Aspose.Imaging for .NET feedback form.

Aspose.Imaging for .NET 24.4

Enhance your API capabilities with the latest update:

Adjust Dicom tags effortlessly via our public API for seamless integration and customization.
Experience improved PNG loading, now supporting files with unexpected end of file (EOF) and optimized PNG loader performance.
Convert DJVU files to PDF effortlessly, ensuring the first page is not blank.
Effortlessly tackle EMF to PDF conversions with enhanced text wrapping.
Resolve issues with converting CDR images to DXF format.
Enjoy smoother EPS to SVG exports with fixes for processing errors and missing text.
Witness a significant performance boost when exporting large SVG files.
Enhance productivity with our latest PS (EPS) file export fixes.

New Feature - Edit DICOM Image Tags

With the most recent update, you now can modify DICOM image tags. You can achieve this by updating an existing tag using the UpdateTagAt() method, adding a new tag with AddTag() methid, or completely removing a tag using the RemoveTagAt() method. Below is a C# code example demonstrating how to load a DICOM image, edit its tags, and then save the edited output images.

using (DicomImage image = (DicomImage)Image.Load("ttfm.dcm"))
{
    image.FileInfo.UpdateTagAt(33, "Test Patient"); // "Patient's Name"
    image.FileInfo.AddTag("Angular View Vector", 234);
    image.FileInfo.RemoveTagAt(29); // "Station Name"

    image.Save("output.dcm");
}

Please visit the Aspose.Imaging 24.4 release notes for more details.

Aspose.Imaging for .NET 24.3

Improve your document conversion experience with our latest enhancements:

Seamlessly transform TIFF files with varying horizontal and vertical resolutions into PDFs, ensuring precise preservation without distortion.
Address unauthorized access exceptions when loading read-only image files, guaranteeing a secure and uninterrupted workflow.

Embrace these advancements today to optimize your document management processes.

For further details, please explore the Aspose.Imaging 24.3 release notes.

Aspose.Imaging for .NET 24.2

Maximize your productivity with our latest release enchantments:

Elevate your productivity with our latest release, featuring enhanced support for kernel filters, enabling stunning image and photo effects.
Seamlessly integrate VSIX files into your workflow with improved recognition as SVG images.
Resolve errors encountered during EPS to PDF conversions, ensuring a seamless transition.
Guarantee faultless output quality with resolved export issues during EPS to JPG conversions.
Accurately recognize MSO files as SVG images, enhancing efficiency in document management.
Optimize memory usage during vector format rendering, enhancing overall performance.
Experience seamless workflow with precise step-by-step loading and rendering of each record.

Embrace these advancements today and elevate your document management experience to new heights.

New Feature - Kernel Filters Support

Kernel filters are essential for image processing, offering a plethora of effects like Blur, Emboss, Gaussian Blur, and more. Aspose.Imaging for .NET goes beyond standard filters, enabling the creation of custom ones for unique image effects. These filters utilize a matrix called a "kernel" to manipulate pixels in the source image, applying the kernel matrix to each pixel through a mathematical convolution operation. Comprehensive code snippets featuring filter applications and accompanied by image examples can be found in our Developers Guide: Kernel Filters for Image Processing article.

For additional details, explore the Aspose.Imaging 24.2 release notes.

Aspose.Imaging for .NET 23.12

Discover enhanced capabilities with our latest release. Introducing powerful additions to our API arsenal:

RemoveBackground and ChangeBackground functionalities now support vector image processing, enabling seamless manipulation of visual elements.
Experience smoother workflows as critical issues encountered during PNG export processes are resolved.
Fixed System.NullReferenceException errors when exporting loaded PNGs with 64 bpp to 32 bpp, ensuring flawless output.
Streamline your operations with optimized DataStreamSupporter.Save functionalities, eliminating interruptions in your export procedures.
Addressed conversion challenges, ensuring smooth transitions from EMF files to PDF formats.
Fixed issues related to resizing PNG images, enhancing image management capabilities.
Enjoy uninterrupted functionality as EMF files seamlessly convert to SVG even in trial mode.

New Feature - Remove and Change Background for Vector Images

Aspose.Imaging for .NET now offers robust background removal capabilities not only for raster images but also for vector formats like SVG, EMF, and CDR. Unlike raster images, background removal in vector files involves identifying and isolating objects without underlying shapes considered part of the background. The library allows you to specify a background color for removal, excluding foreground elements of the same color. Additionally, targeted background removal within specific areas of the image is possible. Removed backgrounds with the RemoveBackground() method of `VectorImage` class, can be replaced with a new color or saved as foreground shapes on a transparent layer, providing flexibility and precision in image editing. To access C# code snippets and image examples illustrating background removal before and after, please refer to our Developer Guide article "Remove background from vector images in C#". It contains detailed demonstrations that will guide you through the process effectively.

Upgrade today and increase efficiency in your image processing workflows. You can find additional insights and explanations in the Aspose.Imaging 23.12 release notes.

Aspose.Imaging for .NET 23.11

Experience enhanced versatility with our latest update:

Seamlessly implement text styles such as italic and underline in CDR format, enhancing design possibilities with greater flexibility.
Streamline workflows with improved PNG to PSD conversions, ensuring seamless transitions and preserving image integrity.
Resolve issues opening CMX files and converting them to PNG format.
Accurately convert EMF files to PNG, eliminating discrepancies and preserving visual quality.
Fix System.NullReferenceException errors encountered during specific CDR to PNG conversions, ensuring smooth and reliable operations.
Experience smoother SVG to PNG conversions as underlying issues are addressed, ensuring consistent and reliable outcomes.

New Feature - Italic and Underline Text Styles in CDR Format

Introducing enhanced font support for italic and underline styles in CDR file format! Seamlessly incorporate fonts with these styles into your designs by simply adding a font folder using the `FontSettings.SetFontsFolder()` method. Harness the power of this functionality with ease by following the C# example provided below:

var baseFolder = "D:\\";
FontSettings.SetFontsFolder(Path.Combine(baseFolder, "Fonts"));
using (var image = Image.Load(Path.Combine(baseFolder, "Test.cdr")))
{
    image.Save(Path.Combine(baseFolder, "Test.cdr.jpg"));
}

For additional information, please refer to the Aspose.Imaging 23.11 release notes.

Aspose.Imaging for .NET 23.10

With the release of Aspose.Imaging 23.10, significant changes have been implemented to enhance the interface and behavior of the `EpsImage` class for EPS file manipulation. Here's a summary of the key points:

EpsType Enumeration: Utilize the EpsImage.EpsType property to retrieve the file sub-type, as the EpsInterchangeImage and EpsBinaryImage classes have been deprecated.
Preview Image Retrieval: To obtain a specific preview image or a list of all preview images, utilize the EpsImage.GetPreviewImage(EpsPreviewFormat) method or access the EpsImage.PreviewImages property. This replaces the usage of EpsLoadOptions.PreviewExportFormat and EpsRasterizationOptions.PreviewToExport properties, which have been removed.
EPS File Export: Export EPS file renders using the EpsImage.Save(Stream, ImageOptionsBase) method. The EpsPreviewFormat.PostScriptRendering property is no longer available.

These changes streamline EPS file manipulation, providing a more intuitive and efficient workflow. Upgrade to Imaging 23.10 to leverage these enhancements and optimize your EPS file handling processes.

For further details, please consult the Aspose.Imaging 23.10 release notes.

Aspose.Imaging for .NET 23.9

Introducing the latest advancements in Aspsoe.Imaging version 23.10, designed to streamline your image processing workflows while enhancing performance and reliability:

Introducing a Remove Watermark filter, allowing users to effortlessly eliminate unwanted overlays and refine images.
Address the “Required palette is missing” exception encountered during BMP loading, ensuring uninterrupted workflows.
Enhancements made to address GIF file loading issues, providing a smoother user experience.
Resolve exceptions occurring during palette creation for large images, ensuring stability in image processing tasks.
Improve DICOM file loading to ensure accurate rendering and reliable data retrieval.
Resolve errors encountered when inheriting custom classes from Image, ensuring seamless integration and compatibility.

Please note: With this release, we’ve made changes regarding the .NET 5 configuration. Aspose.Imaging version 23.10 will no longer support .NET 5 configurations.

New Feature - Remove watermark filter

A new feature called the Remove Watermark Image Filter managed through the WatermarkRemover class, enables users to remove unwanted watermarks, such as manufacturer logos or device model names, from photos captured by certain smartphones and cameras. This filter provides a convenient solution for users who need to share photos without these unwanted marks, enhancing the overall quality and presentation of their images.

Here's a simple example of how you can use the `WatermarkRemover` class in C# for watermark removal:

var imageFilePath = "ball.png";
var outputFilePath = "result.png";
using (var image = Image.Load(imageFilePath))
{
    var pngImage = (PngImage)image;

    var mask = new GraphicsPath();
    var firstFigure = new Figure();
    firstFigure.AddShape(new EllipseShape(new RectangleF(350, 170, 570 - 350, 400 - 170)));
    mask.AddFigure(firstFigure);

    var options = new ContentAwareFillWatermarkOptions(mask)
    {
        MaxPaintingAttempts = 4
    };

    var result = WatermarkRemover.PaintOver(pngImage, options);

    result .Save(outputFilePath);
}

For a more detailed explanation with pictures and further information, please refer to our Developer Guide article "Remove Watermark Image Filter".

For more in-depth information, please refer to the Aspose.Imaging 23.9 release notes for additional details and updates.

Aspose.Imaging for .NET 23.8

In our latest update:

Introducing the Magic Wand tool, offering precise selection capabilities to refine designs with ease.
Address bugs related to font rendering during SVG exports, ensuring text elements retain their intended appearance.
Resolve issues saving images with dimensions exceeding 65535 pixels to JPEG format, guaranteeing accurate output for high-resolution projects.
Implement improvements for exporting multi-frame GIFs to composite image formats, enhancing workflow efficiency for handling animated content.

New Feature - Magic Wand tool

The Magic Wand tool is indispensable for graphic designers, allowing easy selection of specific color areas in images or photos. By utilizing the MagicWandTool class from the Aspose.Imaging library, designers can select a color area by simply choosing a point within it. The tool automatically extends the selection to include all adjacent areas sharing a similar color, streamlining complex selections and adjustments.

C# code example:

using (RasterImage image = (RasterImage)Image.Load("src.png"))
{
    // Create a new mask using magic wand tool based on tone and color of pixel {845, 128}
    MagicWandTool.Select(image, new MagicWandSettings(845, 128))
        // Union the existing mask with the specified one created by magic wand tool
        .Union(new MagicWandSettings(416, 387))
        // Invert the existing mask
        .Invert()
        // Subtract the specified mask created by magic wand tool from the existing one
        .Subtract(new MagicWandSettings(1482, 346) { Threshold = 69 })
        // Subtract four specified rectangle masks from the existing mask one by one
        .Subtract(new RectangleMask(0, 0, 800, 150))
        .Subtract(new RectangleMask(0, 380, 600, 220))
        .Subtract(new RectangleMask(930, 520, 110, 40))
        .Subtract(new RectangleMask(1370, 400, 120, 200))
        // Feather mask with specified settings
        .GetFeathered(new FeatheringSettings() { Size = 3 })
        // Apply mask to the image
        .Apply();
    image.Save("output.png");
}

For a comprehensive explanation accompanied by images and additional information, please consult our Developer Guide article "Magic Wand tool".

If you require more detailed information, we recommend you refer to the Aspose.Imaging 23.8 release notes.

Aspose.Imaging for .NET 23.7

In our latest update, we've introduced several significant improvements and features:

The addition of the alpha blending feature for RasterImage provides greater control over transparency and layering in projects, enabling dynamic compositions and effects.
Resolve EMF export errors, ensuring seamless compatibility.
Address concerns regarding the CCITT G3 1D decoder to ensure proper functionality and reliable results.
Improve synchronization of page management and format-specific collections for multi-page images, enhancing consistency and efficiency in image processing tasks.

Please note: In line with our commitment to advancing technology, we have discontinued support for configurations utilizing .NET 2.0, .NET 3.5, and .NET 3.5 client profile since Aspose.Imaging version 23.7.

New Feature - Alpha Blending

In today's online landscape, captivating users is increasingly challenging. However, beyond artistic endeavors, Alpha Blending image filters play a crucial role, particularly in watermarking images. They not only assert ownership but also promote individual or corporate identity effectively. By overlaying a semi-transparent logo onto the original document, the author's ownership is established discreetly yet prominently. The provided C# code example demonstrates the application of this technique, utilizing the Blend() method from the `RasterImage` class. This method seamlessly combines two images, background and overlay, enabling the efficient creation of visually engaging compositions, including watermarks, with ease.

using var background = Image.Load("background.webp") as RasterImage;
using var overlay = Image.Load("logo.png") as RasterImage;

var center = new Point((background.Width - overlay.Width) / 2, (background.Height - overlay.Height) / 2);
background.Blend(center, overlay, overlay.Bounds, 127);

background.Save("blended.webp");

Please explore our Developers Guide article "Alpha Blending Image Filter" for more detailed explanations accompanied by image examples.

For more information about the release, please visit the Aspose.Imaging 23.7 release notes.

Aspose.Imaging for .NET 23.6

With our latest update, we've addressed several key issues to provide you with a smoother and more reliable workflow:

Resolve the occurrence of evaluation watermarks inadvertently added to output files when converting DCM images.
Tackle a NullReferenceException error encountered when converting EMF files to SVG format, ensuring smooth conversions.
Address a regression issue where EXIF data was missing, ensuring images retain metadata for accurate organization and management.

With the release of version 23.6, Aspose.Imaging for .NET now fully supports Aspose.Drawing for .NET7 configuration as the default graphics engine. This integration brings a host of benefits, including advanced rendering capabilities, improved efficiency and compatibility.

For further details about the release, please visit the Aspose.Imaging 23.6 release notes.

Aspose.Imaging for .NET 23.5

We're pleased to unveil our latest Imaging graphic library update, introducing a range of enhancements tailored to optimize your image processing workflows:

Support for tiled TIFF writing and rectification of incorrect orientation issues with WMF rendering.
Ensure accurate arrow rendering when converting SVG files to PDF format.
Support for TIFF files with CMYK Alpha color mode and seamless conversion of PNG images to TIFF with preserved CMYK colorspace and transparency.
Address exceptions encountered during PNG file rendering to PNG format.

We've introduced support for .NET7 configuration, providing you with even greater flexibility and compatibility in your development environment. Now, you can seamlessly integrate our Imaging library into your .NET7 projects.

New Feature - TIFF Tiled Writing

The tiled TIFF writing feature empowers you to efficiently handle large images with ease. Below is a sample C# code demonstrating how to load and save tiled TIFF files:

using var image = Image.Load("tiled-tiff.tiff") as TiffImage;

var page = image.Pages[0] as TiffFrame;
if (page.FrameOptions.IsTiled)
{
    Console.WriteLine("Tiff is tiled");
}

image.Save("output-tiled.tiff");

For additional details about the release, please refer to the Aspose.Imaging 23.5 release notes.

Aspose.Imaging for .NET 23.4

Introducing our latest release, packed with enhancements to elevate your image processing workflows:

Support for rendering image raw data from EPS files provides greater flexibility and control over designs.
Removal of unsafe BinaryFormatter ensures improved security and reliability in serialization tasks.
Resolve DICOM loading issues under ARM64 mode for seamless operations across platforms.
Rectify export inconsistencies, including bottom-right shifted content in EMF images exported to PNG format and incorrect text offsets in EMF formulas rasterization.
Address issues related to object disposal after ICO image conversion, ensuring smoother transitions throughout workflows.

New Feature - Image Raw Data Rendering from EPS

The rendering of image raw data from EPS files provides enhanced flexibility and control over your image rendering process. Below is a code example in C# of exporting EPS files to PNG format:

var options = new EpsLoadOptions { PreviewExportFormat = EpsPreviewFormat.PostScriptRendering, };
using (var image = Image.Load("input.eps", options))
{
    image.Save("output.png");
}

For further information, please consult the Aspose.Imaging 23.4 release notes.

Aspose.Imaging for .NET 23.3

Announcing our latest release, featuring a range of enhancements to elevate your image processing experience:

Added support for BigTIFF makes handling larger image files more seamless than ever.
Fixed compatibility issues when resultant PNG files opened in Photoshop.
Addressed a specific issue on Linux systems where converting EMZ files resulted in a “Cannot access a closed file” error.
Improvements made to the functionality of WmfImage.Crop, resolving inaccuracies and preventing exceptions with certain files.

New Feature - BigTIFF Image Support

With the BigTiffImage class implementation, you can now effortlessly handle larger image files with ease. Here's an example of loading and exporting BigTIFF images in C#:

var inputPath = "input-BigTIFF.tif";
var outputPath = "output-BigTIFF.tif";

using (var image = Image.Load(inputPath) as BigTiffImage)
{
    image.Save(outputPath, new BigTiffOptions(TiffExpectedFormat.TiffLzwRgba));
}

For more detailed information, please check the Aspose.Imaging 23.3 release notes.

Aspose.Imaging for .NET 23.2

We're excited to introduce our new release in 2023, which includes enhancements designed to elevate your image processing experience:

Introducing plug-in licensing development for enhanced flexibility and management.
Preserve transparency in indexed PNG images for seamless integration.
Address bug in ICO to PDF export process for improved reliability.
Optimize conversion speed in RasterImage.ToBitmap() method for faster performance.
Resolve SVG export issue for accurate rendering and compatibility.
Fix image export failure when converting DCM to PNG format.
Ensure text preservation when converting from SVG to JPG format.
Improve color retention in TIFF to PDF conversion process.

New Feature - Plugin Licensing

Aspose.Imaging now introduces Plugin licensing, enabling access to specific features and functions tailored to your needs. With support for .NET Standard 2.0 and higher configurations, you can now acquire licenses for the exact capabilities you require. Our Plugin licensing system ensures you get precisely what you need, maximizing efficiency and minimizing unnecessary costs.

To acquire Plugin licenses or learn more about available options, please visit our Purchase page. Additionally, detailed descriptions of available plugins can be found in the Licensing Plugins Documentation. This provides you with comprehensive information to make informed decisions about which plugins best suit your requirements.

Example of using Licensing plugin in C#:

// Valid plugin license use example
Metered license = new Metered();
// Only one metered plug-in license is supported
license.SetMeteredKey("<your public key>", "<your private key>");

New Feature - Export Indexed PNG Images with Transparency

The latest release introduced the ability to maintain transparency when indexing PNG images. Here's a C# code example illustrating how to load a PNG image with an alpha channel and save it with indexed colors while preserving transparency:

using (RasterImage image = (RasterImage)Image.Load("input_png_with_alpha.png"))
{
    PngOptions options = new PngOptions()
    {
        CompressionLevel = 9,
        ColorType = PngColorType.IndexedColor,
        Palette = ColorPaletteHelper.GetCloseTransparentImagePalette(image, 256),
        FilterType = PngFilterType.Avg,
    };

    image.Save("input_png_with_alpha.png.png", options);
}

For further insights, please review the Aspose.Imaging 23.2 release notes.

Product Overview