Skip to main content

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.

Project description

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 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
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
	# fill the background with blue color
	# 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
	# save image in a file"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.draw_line(Pen(, 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) # 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)"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)"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, "output.webp"), WebPOptions())
	# convert to psd, "output.psd "), PsdOptions())
	# convert to tiff, "output.tiff"), TiffOptions(TiffExpectedFormat.DEFAULT))
	# convert to pdf
	export_options = PdfOptions()
	export_options.pdf_document_info = PdfDocumentInfo(), "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)

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

def merge_images(direction, out_file_name):
	target_width = 0
	target_height = 0
	if direction == 0:
		target_width = total_width
		target_height = max_height
		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
				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

# 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 _:

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

Project details

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distributions

No source distribution files available for this release.See tutorial on generating distribution archives.

Built Distributions

Supported by

AWS AWS Cloud computing and Security Sponsor Datadog Datadog Monitoring Fastly Fastly CDN Google Google Download Analytics Microsoft Microsoft PSF Sponsor Pingdom Pingdom Monitoring Sentry Sentry Error logging StatusPage StatusPage Status page