Aspose.Imaging for Python via .NET 26.2 - Release notes

from aspose.pycore import as_of, is_assignable
from aspose.imaging import Image, LoadOptions, RasterImage
from aspose.imaging.imageoptions import PdfOptions

horizontalResolutionFromImage = 72.0
verticalResolutionFromImage = 72.0
InputFile = "Landscape_Keine.jpg"
outputFile = "Landscape_Keine.jpg_py.pdf"

with Image.load(InputFile, LoadOptions()) as image:
    if is_assignable(image, RasterImage):
        rasterImage = as_of(image, RasterImage)
        horizontalResolutionFromImage = rasterImage.horizontal_resolution
        verticalResolutionFromImage = rasterImage.vertical_resolution
        # Here we check the "logical" rotation and if it is need we perform rotation.
        rasterImage.auto_rotate()

    with PdfOptions() as exportOptions:
        image.save(outputFile, exportOptions)

from aspose.imaging import Image

with Image.load(r"D:\sample.cdr") as image:
	image.save(r"D:\sample.cdr.png")

from aspose.pycore import as_of
from aspose.imaging import Image, RasterImage
from aspose.imaging.imageloadoptions import JpegLoadOptions, JpegDecoderQuality
from os.path import join as path_combine

basePath = "D:\\"
inputFilePath = path_combine(basePath, "manor_normal.jpg")
referenceFiles = ["photoshop.png", "paint.png"]
expectedMinimums = [6.5, 3.0]
i = 0
for fileName in referenceFiles:
    referenceFilePath = path_combine(basePath, fileName)
    with as_of(Image.load(referenceFilePath), RasterImage) as image:
        referenceColors = image.load_pixels(image.bounds)

    totalAvg = 0.0
    load_options = JpegLoadOptions()
    load_options.jpeg_decoder_quality = JpegDecoderQuality.FINE
    with as_of(Image.load(inputFilePath, load_options), RasterImage) as image:
        pixels = image.load_pixels(image.bounds)
        idx = 0

        for pixel in pixels:
            referenceColor = referenceColors[idx]
            idx += 1
            if referenceColor != pixel:
                totalAvg += 1.0

    totalAvg *= 100.0 / len(referenceColors)
    if totalAvg > expectedMinimums[i]:
        raise AssertError(f"Avg={totalAvg}%, ExpectedAvg={expectedMinimums[i]}%")

    i += 1

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

start_time = time.perf_counter()
with Image.load(pngStream) as image:
    if image.file_format == FileFormat.PNG:
        pngImage = as_of(image, PngImage)
        pixels = pngImage.load_argb_32_pixels(pngImage.bounds)
        end_time = time.perf_counter()
        execution_time = end_time - start_time
        print(f"Png pixels loading took {execution_time:.4f} seconds.")

from os.path import join as path_combine
from aspose.pycore import as_of
from aspose.imaging import Image, RasterImage
from aspose.imaging.fileformats.png import PngImage
from aspose.imaging.fileformats.core.photo.hdr import HdrImageOptions, HdrProcessor

baseFolder = "D:\\test\\hdr"
sourceFiles = ["DSC_6918.jpg", "DSC_6919.jpg", "DSC_6920.jpg"]
images = []
for sourceFile in sourceFiles:
    sourcePath = path_combine(baseFolder, sourceFile)
    images.append(as_of(Image.load(sourcePath), RasterImage))

options = HdrImageOptions()
options.sample_count = 100
options.smooth_factor = 200
options.align_images = True

pixels = HdrProcessor.process(images, options)

resultPath = path_combine(baseFolder, "hdr.jpg")
with PngImage(images[0].width, images[0].height) as image:
    image.save_argb_32_pixels(image.bounds, pixels)
    image.save(resultPath)

# releasing the images
for image in images:
    with image as _:
        pass

from aspose.imaging import Image
from os.path import join as path_combine

baseFolder = "D:\\"
fileName = "2020 BCF Golf Program.cdr"
inputFilePath = path_combine(baseFolder, fileName)
outputFilePath = inputFilePath + ".pdf"
with Image.load(inputFilePath) as image:
   image.save(outputFilePath)