What's New in Aspose.Imaging for Python via .NET

Aspose.Imaging for Python via .NET 24.8

         Updates in Aspose.Imaging 24.8:

  • Support Python 3.12
  • Add ability to load image from URL.

Upgrade to the latest version of today to experience these enhancements and more.

For additional information, kindly review the accompanying Aspose.Imaging 24.8 release notes.

Aspose.Imaging for Python via .NET 24.7

         Updates in Aspose.Imaging 24.7:

  • Support Dicom YBR 422.

Upgrade to the latest version of today to experience these enhancements and more.

For additional information, kindly review the accompanying Aspose.Imaging 24.7 release notes.

Aspose.Imaging for Python via .NET 24.6

         Exciting updates in Aspose.Imaging:

  • ExifData Transfer: Seamlessly transfer ExifData between supported formats during export for enhanced metadata handling.
  • Emfplus Text Alignment Fix: Bugs affecting text alignment in Emfplus have been resolved for improved rendering accuracy.
  • Enhanced Format Detection: All unknown formats detected after identifying SVG are now recognized as SVG for streamlined processing.
  • Transparent PNG to TIFF Deflate RGB: Transparency preservation in PNG to TIFF Deflate RGB conversion now ensures transparent colors remain white, not black.
  • DICOM Export Issue Resolution: We’ve addressed issues related to DICOM export for smoother workflow operations.
  • DICOM to PDF Conversion Fix: Convert DICOM images to PDF seamlessly with resolved conversion issues.
  • DICOM to JPEG Conversion: Easily convert DICOM images to JPEG format without encountering any conversion barriers.

New Feature - Enhanced ExifData Transfer on Export

         In our latest update, we are pleased to announce a powerful new feature: the ability to transfer ExifData between supporting formats during export. With this enhancement, you can now seamlessly preserve and transfer Exif metadata when exporting images to compatible formats. Whether you're converting images for web use, archiving, or sharing, this feature ensures that crucial metadata such as camera settings, date/time information, and location data remain intact, enhancing the overall usability and fidelity of exported images. Say goodbye to lost metadata and hello to a more streamlined and efficient workflow with our enhanced ExifData transfer functionality.

For further details, please refer to the provided Aspose.Imaging 24.7 release notes.

Aspose.Imaging for Python via .NET 24.5

         We're thrilled to announce the latest updates to Aspose.Imaging, packed with enhancements and fixes to streamline your imaging experience. Here's what's new:

  • Enhanced EPS Compatibility: We’ve resolved a range of EPS-related issues, including font rendering extensions and functionality improvements.
  • Smooth EPS to PNG Conversion: We’ve fixed the EPS to PNG export issue for seamless conversions.
  • Perfect GIF Output: Our update ensures saving GIF files produces perfectly rendered outputs.
  • Precise EmfPlus Rendering: Experience accurate EmfPlus rendering with our bug fixes, ensuring images display correctly.
  • Improved EPS to SVG Conversion: Incorrect EPS to SVG conversions are a thing of the past with our latest enhancements.

Upgrade to the latest version of today to experience these enhancements and more.

For additional information, kindly review the accompanying Aspose.Imaging 24.5 release notes.

Aspose.Imaging for Python via .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.

         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.

         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 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.

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 update_tag_at() method, adding a new tag with add_tag() methid, or completely removing a tag using the remove_tag_at() method. Below is a python code example demonstrating how to load a DICOM image, edit its tags, and then save the edited output images. 

from aspose.pycore import as_of
from aspose.imaging import Image
from aspose.imaging.fileformats.dicom import DicomImage

with as_of(Image.Load("ttfm.dcm"), DicomImage) as image:
    image.file_info.update_tag_at(33, "Test Patient") # "Patient's Name"
    image.file_info.add_tag("Angular View Vector", 234)
    image.file_info.remove_tag_at(29) # "Station Name"
    image.save("output.dcm")

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

Aspose.Imaging for Python via .NET 23.12

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

  • remove_background and change_background 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 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 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 remove_background() 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 python code snippets and image examples illustrating background removal before and after, please refer to our Developer Guide article "Remove background from vector images in python". 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 Python via .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 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.set_fonts_folder()` method. Harness the power of this functionality with ease by following the python example provided below: 


import os
from aspose.imaging import Image

baseFolder = "D:\\"
FontSettings.set_fonts_folder(os.path.join(baseFolder, "Fonts"))
with Image.load(os.path.join(baseFolder, "Test.cdr")) as image:
    image.save(os.path.join(baseFolder, "Test.cdr.jpg"))

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

Aspose.Imaging for Python via .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.get_preview_image(EpsPreviewFormat) method or access the EpsImage.preview_images property. This replaces the usage of EpsLoadOptions.preview_export_format and EpsRasterizationOptions.preview_to_export properties, which have been removed.

  • EPS File Export: Export EPS file renders using the EpsImage.save(stream, options_base) method. The EpsPreviewFormat.post_script_rendering 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 Python via .NET 23.9

         Introducing the latest advancements in Aspose.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.

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 python for watermark removal: 

from aspose.pycore import as_of
from aspose.imaging import Image, GraphicsPath, Figure, RectangleF
from aspose.imaging.shapes import EllipseShape
from aspose.imaging.fileformats.png import PngImage
from aspose.imaging.watermark import WatermarkRemover
from aspose.imaging.watermark.options import ContentAwareFillWatermarkOptions

imageFilePath = "ball.png"
outputFilePath = "result.png"
with Image.load(imageFilePath) as image:
    pngImage = as_of(image, PngImage)
    mask = GraphicsPath()
    firstFigure = Figure()
    firstFigure.add_shape(EllipseShape(RectangleF(350, 170, 570 - 350, 400 - 170)))
    mask.add_figure(firstFigure)
    options = ContentAwareFillWatermarkOptions(mask)
    options.max_painting_attempts = 4
    result = WatermarkRemover.paint_over(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 Python via .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.

Python code example:

from aspose.imaging import Image, RasterImage
from aspose.imaging.magicwand import *
from aspose.imaging.magicwand.imagemasks import *
import os
import aspose.pycore as ascore

with ascore.as_of(Image.load("src.png"), RasterImage) as image:
	wand_set = MagicWandSettings(1482, 346)
	wand_set.threshold = 69
	f_set = FeatheringSettings()
	f_set.size = 3
	# Create a new mask using magic wand tool based on tone and color of pixel {845, 128}
	tool = MagicWandTool.select(image, MagicWandSettings(845, 128))
	# Union the existing mask with the specified one created by magic wand tool
	tool = tool.union(MagicWandSettings(416, 387))
	# Invert the existing mask
	tool = tool.invert()
	# Subtract the specified mask created by magic wand tool from the existing one
	tool = tool.subtract(wand_set)
	# Subtract four specified rectangle masks from the existing mask one by one
	tool = tool.subtract(RectangleMask(0, 0, 800, 150))\
		.subtract(RectangleMask(0, 380, 600, 220))\
		.subtract(RectangleMask(930, 520, 110, 40))\
		.subtract(RectangleMask(1370, 400, 120, 200))
	# Feather mask with specified settings
	tool = tool.get_feathered(f_set)
	# Apply mask to the image
	tool.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 Python via .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.

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 python 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. 

import aspose.pycore import as_of
import aspose.imaging import Image, RasterImage, Point

with as_of(Image.load("background.webp"), RasterImage), \
	       as_of(Image.load("logo.png"), RasterImage):

	center = 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 Python via .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.

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

Aspose.Imaging for Python via .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.

New Feature - TIFF Tiled Writing

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


from aspose.imaging import Image
from aspose.imaging.fileformats.tiff import TiffImage, TiffFrame
import aspose.pycore

with aspose.pycore.as_of(Image.load("tiled-tiff.tiff"), TiffImage) as image:
	page = aspose.pycore.as_of(image.pages[0], TiffFrame)
	if page.frame_options.is_tiled:
		print("Tiff is tiled")

	image.save("output-tiled.tiff")

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

Product Overview