aspose-imaging-python-net 23.11.0

Aspose.Imaging for Python via .NET is Another Python Imaging Library. It allows developers to easily create, load, manipulate, convert, compress images or photos using this API.

Imaging Manipulation API

Last changes

• Added support of MacOS based on M1/M2/M3 processors (arm64 platform)
• Changed the base .NET platform from .NET Core 3.1 to .NET Core 6.0
• Eliminated the dependency on the System.Drawing.Common and replaced by the platform-independent Aspose.Drawing.

Product Page | Documentation | Demos | Blog | API Reference | Search | Free Support | Temporary License | EULA

---

Try our free online Apps demonstrating some of the most popular Aspose.Imaging functionality.

Aspose.Imaging for Python via .NET is Another Python Imaging Library offering advanced image processing features. You could easily create, load, manipulate, convert, compress images or photos using this API. Also Aspose.Imaging library supports drawing and work with graphic primitives. Image export and conversion (including uniform multi-page image processing) is the one of API core features along with image transformations (resize, crop, flip&rotate, binarization, grayscale, adjust, etc.), advanced image manipulation features (filtering, dithering, masking, deskewing) and memory optimization strategies.

Aspose.Imaging for Python via .NET is a flexible, stable and powerful API, capable of processing the most commonly used formats along with some special formats such as DjVu, DICOM, WebP & DNG. Moreover, it extends the native support for image formats & processing functions for .NET and .NET Core. Aspose.Imaging is cross-platform library, it is Windows x32/x64, Linux x64, and MacOS x64/Arm64 compatible.

Aspose.Imaging for Python requires you to use python programming language. For Java and .NET languages, we recommend you get Aspose.Imaging for Java and Aspose.Imaging for .NET, respectively.

Product Features

The following are Aspose.Imaging’s core features:

• Create images (raster, vector)
• Read images (raster, vector)
• Write images (raster, vector)
• Draw lines, circles, ellipses, texts, complex paths, and images using the classes Graphics, SvgGraphics2D, EmfRecorderGraphics2D, WmfRecorderGraphics2D
• Process images (including per-pixel modifications)
• Convert between different image formats as raster as vector
• Support the large images with size more than 100000x100000 pixels
• Memory and performance management strategies

Supported File Formats

File format	Supported versions	Load	Save
BMP	BMP Specification v5	Yes	Yes
GIF	Version 89a	Yes	Yes
DICOM	Version 3.0	Yes	Yes
DJVU	Version 3.0	Yes
DNG	Version 1.0.0.0 and later	Yes
EMF	Revision 11.0	Yes	Yes
JPEG	CCITT Rec. T.81 (1992 E)	Yes	Yes
JPEG2000	ITU-T Rec. T.800 (08/2002 E)	Yes	Yes
ODG	Version 1.2	Yes
PNG	Version 1.0 and later	Yes	Yes
ICO	Version 1.0 and later	Yes	Yes
APNG		Yes	Yes
PSD	Adobe Photoshop 2.0 and later		Yes
DXF	Dxf 6 and later		Yes
SVG	Version 1.1	Yes	Yes
TIFF	Version 6.0*	Yes	Yes
BIG-TIFF		Yes	Yes
DIB	BMP Specification v5	Yes
EPS		Yes
WEBP		Yes
WMF	Revision 13.0	Yes	Yes
CDR	Version X7, X6 (3-x5 not completely)	Yes
CMX	Version 2.0, 32 bit precision (16 bit precision not completely)	Yes
OTG	Version 1.2	Yes
PDF	Portable document format		Yes
HTML5 canvas	Html5 canvas element		Yes
EMZ	Compressed emf format	Yes	Yes
WMZ	Compressed wmf format	Yes	Yes
TGA	Truevision TGA (TARGA)	Yes	Yes
SVGZ	Compressed svg file format	Yes	Yes

Platform Independence

Aspose.Imaging for Python can be used to develop applications for a vast range of operating systems, such as Windows (x32/x64), Linux (x64), and MacOS (x64/arm64) where Python 3.5 or later is installed.

Get Started

Ready to give Aspose.Imaging for Python a try?

Simply run pip install aspose-imaging-python-net from the Console to fetch the package. If you already have Aspose.Imaging for Python and want to upgrade the version, please run pip install --upgrade aspose-imaging-python-net to get the latest version.

You can run the following snippets in your environment to see how Aspose.Imaging works, or check out the GitHub Repository or Aspose.Imaging for Python Documentation for other common use cases.

Create a PNG image from scratch in Python

from aspose.imaging import Color, Graphics, Pen
from aspose.imaging.fileformats.png import PngImage

# create an empty PNG image
with PngImage(100, 100) as png:
	# create a canvas for drawing over the image
	g = Graphics(png)
	# start a queue of operations which will be processed together as a batch
	g.begin_update()
	# fill the background with blue color
	g.clear(Color.blue)
	# draw a line with light green pen with width == 2.0
	g.draw_line(Pen(Color.light_green, 2.0), 0, 10, 100, 90)
	# execute all drawing operations as one
	g.end_update()
	# save image in a file
	png.save("output.png")
	

Create and manipulate with PNG image

from aspose.imaging import Image, ResizeType, Graphics, Color, Pen, Rectangle
from aspose.imaging.fileformats.png import PngImage
from aspose.imaging.imageoptions import PngOptions
from aspose.imaging.sources import FileCreateSource
from aspose.pycore import as_of
import os

data_dir = "~/data-dir"
width = 500
height = 300
path = os.path.join(data_dir, "result.png")
with PngOptions() as options:
	options.source = FileCreateSource(path, False)
	with as_of(Image.create(options, width, height), PngImage) as image:
		graphic = Graphics(image)
		graphic.clear(Color.green)
		graphic.draw_line(Pen(Color.blue), 9, 9, 90, 90)
		new_width = 400
		image.resize_width_proportionally(new_width, ResizeType.LANCZOS_RESAMPLE)
		area = Rectangle(10, 10, 200, 200)
		image.crop(area)
		image.save() # save into the file set to options.source

Load, resize and save a raster image

from aspose.imaging import Image

with Image.load("any-picture.tiff") as image:
	image.resize(image.width // 2, image.height // 2)
	image.save("output.jpeg")

Load a raster image (PNG) and convert it into jpeg

from aspose.imaging import Image, FileFormat
from aspose.imaging.fileformats.png import PngImage
import aspose.pycore as pycore

with Image.load("any-picture.png") as image:
	print("format: ", FileFormat(image.file_format).name)
	# for accessing to a PngImage properties and methods need to cast it
	png_image = pycore.as_of(image, PngImage)
	print("xmp_data", png_image.xmp_data)
	
	image.save("output.jpeg")
    

Load jpeg and export it into the different formats

from aspose.imaging import Image
from aspose.imaging.fileformats.pdf import PdfDocumentInfo
from aspose.imaging.fileformats.tiff.enums import *
from aspose.imaging.imageoptions import *
import os

data_dir = "data-dir"
with Image.load(os.path.join(data_dir, "template.jpg")) as img:
	# convert to webp
	img.save(os.path.join(data_dir, "output.webp"), WebPOptions())
	# convert to psd
	img.save(os.path.join(data_dir, "output.psd "), PsdOptions())
	# convert to tiff
	img.save(os.path.join(data_dir, "output.tiff"), TiffOptions(TiffExpectedFormat.DEFAULT))
	# convert to pdf
	export_options = PdfOptions()
	export_options.pdf_document_info = PdfDocumentInfo()
	img.save(os.path.join(data_dir, "output.pdf"), export_options)

Crop image

from aspose.pycore import as_of
from aspose.imaging import Image, Rectangle, RasterImage
import os

data_dir = "data-dir"
with Image.load(os.path.join(data_dir, "template.jpg")) as img:
	# casting to the RasterImage class
	raster_image = as_of(img, RasterImage)
	# crop
	area = Rectangle(10, 10, img.width - 20, img.height - 20)
	raster_image.crop(area)
	image.save("cropped.jpg")

Merge images into one (collage)

from aspose.imaging import Image, Graphics, Color, RectangleF
from aspose.imaging.fileformats.png import PngColorType
from aspose.imaging.imageoptions import PngOptions
from aspose.imaging.sources import FileCreateSource
import os

data_dir = "data-dir"
images = []
# files for merging
files = ["template.png", "template.jpg"] # could be more file here
max_width = 0
max_height = 0
total_width = 0
total_height = 0
for file_name in files:
	image = Image.load(os.path.join(data_dir, file_name))
	total_width += image.width
	if image.width > max_width:
		max_width = image.width
	total_height += image.height
	if image.height > max_height:
		max_height = image.height
	images.append(image)


def merge_images(direction, out_file_name):
	target_width = 0
	target_height = 0
	if direction == 0:
		target_width = total_width
		target_height = max_height
	else:
		target_width = max_width
		target_height = total_height

	output_path = os.path.join(data_dir, out_file_name + ".png")
	with PngOptions() as png_options:
		png_options.color_type = PngColorType.TRUECOLOR_WITH_ALPHA
		
		with open(out_file_name, "wb") as stream:
			png_options.source = FileCreateSource(output_path, False)
			with Image.create(png_options, target_width, target_height) as image:
				image.background_color = Color.white
				graphics = Graphics(image)
				x = 0
				y = 0
				graphics.begin_update()
				for frame in images:
					print("x", x, "y", y)
					graphics.draw_image(frame, RectangleF(x, y, frame.width, frame.height))
					if direction == 0:
						x += frame.width
					if direction == 1:
						y += frame.height
						
				graphics.end_update()
				image.save(output_path)


# run 
merge_images(0, "collage_horizontal")
merge_images(1, "collage_vertical")

for image in images:
	# to dispose the image we call __exit__()
	with image as _:
		pass

---

Product Page | Documentation | Demos | Blog | API Reference | Search | Free Support | Temporary License | EULA