aspose-imaging-python-net 26.2.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

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
APNG	Animated Portable Network Graphics	Yes	Yes
AVIF	AVIF (AV1 Image File Format) Version 1.0+	Yes	No
BIG-TIFF	BigTIFF is a TIFF variant file format which uses 64-bit offsets and supports much larger files (up to 18 exabytes in size).	Yes	Yes
BMP	BMP Specification v5	Yes	Yes
CDR	Version X7, X6 (3-x5 not completely)	Yes	No
CMX	Version 2.0, 32 bit precision (16 bit precision not completely)	Yes	No
DIB	BMP Specification v5	Yes	No
DICOM	Version 3.0	Yes	Yes
DJVU	Version 3.0	Yes	No
DNG	Version 1.0.0.0 and later	Yes	No
DXF	Dxf 6 and later	No	Yes
EMF	Revision 11.0	Yes	Yes
EMZ	Compressed emf format	Yes	Yes
EPS	Encapsulated Postscript file format	Yes	No
GIF	Version 89a	Yes	Yes
HTML5 canvas	Html5 canvas element	No	Yes
ICO	Version 1.0 and later	Yes	Yes
JPEG2000	ITU-T Rec. T.800 (08/2002 E)	Yes	Yes
JPEG	CCITT Rec. T.81 (1992 E)	Yes	Yes
ODG	Version 1.2	Yes	No
OTG	Version 1.2	Yes	No
PDF	Portable document format	No	Yes
PNG	Version 1.0 and later	Yes	Yes
PSD	Adobe Photoshop 2.0 and later	No	Yes
SVGZ	Compressed svg file format	Yes	Yes
SVG	Version 1.1	Yes	Yes
TGA	Truevision TGA (TARGA)	Yes	Yes
TIFF	Version 6.0*	Yes	Yes
WEBP	WebP is a raster graphics file format developed by Google intended as a replacement for JPEG, PNG, and GIF file formats. It supports both lossy and lossless compression,[8] as well as animation and alpha transparency.	Yes	No
WMF	Revision 13.0	Yes	Yes
WMZ	Compressed wmf 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 (since 3.13) is installed.

The base .NET platform is .NET Core 6.0 Do not use System.Drawing.Common but the platform-independent Aspose.Drawing.

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