ImageOptionsBase Class

Summary: The image base options.

Full Name: aspose.imaging.ImageOptionsBase

Inheritance: IHasXmpData, IHasMetadata, DisposableObject

Properties

Name	Type	Access	Description
buffer_size_hint	int	r/w	Gets or sets the buffer size hint which is defined max allowed size for all internal buffers.
disposed	bool	r	Gets a value indicating whether this instance is disposed.
full_frame	bool	r/w	Gets or sets a value indicating whether [full frame].
keep_metadata	bool	r/w	Gets a value whether to keep original image metadata on export.
multi_page_options	MultiPageOptions	r/w	The multipage options
palette	IColorPalette	r/w	Gets or sets the color palette.
resolution_settings	ResolutionSetting	r/w	Gets or sets the resolution settings.
source	Source	r/w	Gets or sets the source to create image in.
vector_rasterization_options	VectorRasterizationOptions	r/w	Gets or sets the vector rasterization options.
xmp_data	XmpPacketWrapper	r/w	Gets or sets the XMP metadata container.

Methods

Name	Description
clone()	Clones this instance.

Property: palette

Gets or sets the color palette.

See also:

Example # 1: The following example shows how to set a palette to a BMP image to reduce its…

Example # 2: The following example shows how to compress a PNG image, using indexed color …

Example # 3: The following example loads a BMP image and saves it back to BMP using variou…

Property: resolution_settings

Gets or sets the resolution settings.

See also:

Example # 1: The following example loads a BMP image and saves it back to BMP using variou…

Example # 2: The following example creates a palettized grayscale BMP image and then saves…

Method: clone()

 clone()

Clones this instance.

Returns

Type	Description
ImageOptionsBase	Returns shallow copy of this instance

Examples

The following example shows how to set a palette to a BMP image to reduce its output size.


from aspose.pycore import as_of
from aspose.imaging import Point, Color, Graphics, ColorPaletteHelper
from aspose.imaging.brushes import LinearGradientBrush
from aspose.imaging.fileformats.bmp import BmpImage
from aspose.imaging.imageoptions import BmpOptions
from os.path import join as path_join

# Create a BMP image 100 x 100 px.
with BmpImage(100, 100) as bmpImage:
	# The linear gradient from the left-top to the right-bottom corner of the image.
	brush = LinearGradientBrush(Point(0, 0), Point(bmpImage.width, bmpImage.height),
								Color.red,
								Color.green)
	# Fill the entire image with the linear gradient brush.
	gr = Graphics(bmpImage)
	gr.fill_rectangle(brush, bmpImage.bounds)
	# Get the closest 8-bit color palette which covers as many pixels as possible, so that a palettized image
	# is almost visually indistinguishable from a bmp without palette
	palette = ColorPaletteHelper.get_close_image_palette(bmpImage, 256)
	# 8-bit palette contains at most 256 colors.
	saveOptions = BmpOptions()
	saveOptions.palette = palette
	saveOptions.bits_per_pixel = 8
	
	with stream_ext.create_memory_stream() as stream:
		bmpImage.save(stream, saveOptions)
		print(f"The size of image with palette is {stream.tell()} bytes.")
		stream.seek(0)
		bmpImage.save(stream)
		print(f"The size of image without palette is {stream.tell()} bytes.")

# The output looks like this:
# The size of image with palette is 11078 bytes.
# The size of image without palette is 40054 bytes.

The following example shows how to compress a PNG image, using indexed color with best fit palette


from aspose.pycore import as_of
from aspose.imaging import Image, ColorPaletteHelper, RasterImage, PaletteMiningMethod
from aspose.imaging.fileformats.png import PngColorType

# Loads png image        
sourceFilePath = "OriginalRings.png"
outputFilePath = "OriginalRingsOutput.png"
with Image.load(sourceFilePath) as image:
	png_options = PngOptions()
	png_options.progressive = True
	# Use indexed color type
	png_options.color_type = PngColorType.INDEXED_COLOR
	# Use maximal compression
	png_options.compression_level = 9
	# Get the closest 8-bit color palette, covering as many pixels as possible, so that an image
	# with palette is almost visually indistinguishable from an image without a palette.
	png_options.palette = ColorPaletteHelper.get_close_image_palette(
						as_of(image, RasterImage), 256, 
						PaletteMiningMethod.HISTOGRAM)
		 
	image.save(outputFilePath, png_options);
}
# The output file size should be significantly reduced

The following example loads a BMP image and saves it back to BMP using various save options.

from aspose.imaging import Image, RasterImage, ColorPaletteHelper, ResolutionSetting
from aspose.imaging.imageoptions import BmpOptions
from aspose.imaging.fileformats.bmp import BitmapCompression
import os
import aspose.pycore as aspycore

directory = "c:\\temp\\"

with Image.load(os.path.join(directory, "sample.bmp")) as image:
	
	rasterImage = aspycore.as_of(image, RasterImage)

	# Create BmpOptions
	saveOptions = BmpOptions()

	# Use 8 bits per pixel to reduce the size of the output image.
	saveOptions.bits_per_pixel = 8

	# Set the closest 8-bit color palette which covers the maximal number of image pixels, so that a palettized image
	# is almost visually indistinguishable from a non-palletized one.
	saveOptions.palette = ColorPaletteHelper.get_close_image_palette(rasterImage, 256)

	# Save without compression.
	# You can also use RLE-8 compression to reduce the size of the output image.
	saveOptions.compression = BitmapCompression.RGB

	# Set the horizontal and vertical resolution to 96 dpi.
	saveOptions.resolution_settings = ResolutionSetting(96.0, 96.0)

	image.save(os.path.join(directory, "sample.bmpoptions.bmp"), saveOptions)

The following example creates a palettized grayscale BMP image and then saves it to a file.


from os.path import join as path_join
from aspose.imaging import Image, ColorPaletteHelper, ResolutionSetting, Graphics, Point, Color
from aspose.imaging.sources import FileCreateSource
from aspose.imaging.imageoptions import BmpOptions
from aspose.imaging.fileformats.bmp import BitmapCompression
from aspose.imaging.brushes import LinearGradientBrush

directory = "c:\\temp\\"
createOptions = BmpOptions()

# Save to a file
createOptions.source = FileCreateSource(path_join(directory, "output.palette8bit.bmp"), False)
	
# Use 8 bits per pixel to reduce the size of the output image.
createOptions.bits_per_pixel = 8

# Set the standard 8-bit grayscale color palette which covers all grayscale colors.
# If the processed image contains only grayscale colors, then its palettized version
# is visually indistinguishable from a non-palletized one.
createOptions.palette = ColorPaletteHelper.create_8_bit_grayscale(False)

# Save without compression.
# You can also use RLE-8 compression to reduce the size of the output image.
createOptions.compression = BitmapCompression.RGB

# Set the horizontal and vertical resolution to 96 dpi.
createOptions.resolution_settings = ResolutionSetting(96.0, 96.0)

# Create a BMP image of 100 x 100 px and save it to a file.
with Image.create(createOptions, 100, 100) as image:
	graphics = Graphics(image)
	gradientBrush = LinearGradientBrush(Point(0, 0), Point(image.width, image.height), Color.black, Color.white)
	# Fill the image with a grayscale gradient
	graphics.fill_rectangle(gradientBrush, image.bounds)
	image.save()

ImageLoadersRegistry Class ImageResizeSettings Class