ImageOptionsBase‑klass
Innehåll
[
Dölj
]Summary: The image base options.
Module: aspose.imaging
Full Name: aspose.imaging.ImageOptionsBase
Inheritance: IMetadataContainer, IHasExifData, IHasMetadata, IHasXmpData, DisposableObject
Properties
| Name | Type | Access | Description |
|---|---|---|---|
| buffer_size_hint | int | r/w | Hämtar eller anger en ledtråd för buffertstorlek som definierar maximal tillåten storlek för alla interna buffertar. |
| disposed | bool | r | Hämtar ett värde som indikerar om den här instansen är frigjord. |
| exif_data | ExifData | r/w | Hämtar eller anger Exif-data. |
| full_frame | bool | r/w | Hämtar eller anger ett värde som indikerar om [full frame]. |
| keep_metadata | bool | r/w | Hämtar ett värde som anger om originalmetadata för bilden ska behållas vid export. |
| multi_page_options | MultiPageOptions | r/w | Flersidiga alternativ |
| palette | IColorPalette | r/w | Hämtar eller anger färgpaletten. |
| resolution_settings | ResolutionSetting | r/w | Hämtar eller anger upplösningsinställningarna. |
| source | Source | r/w | Hämtar eller anger källan där bilden ska skapas. |
| vector_rasterization_options | VectorRasterizationOptions | r/w | Hämtar eller anger vektorrasteriseringsalternativen. |
| xmp_data | XmpPacketWrapper | r/w | Hämtar eller anger XMP-metadatabehållaren. |
Methods
| Name | Description |
|---|---|
| clone() | Skapar en medlemsvis klon av detta objekt. |
| try_set_metadata(metadata) | Försöker sätta en metadata-instans, om detta Image-instans stödjer och implementerar IImageMetadataFormat-instansen. |
Property: buffer_size_hint
Hämtar eller anger en ledtråd för buffertstorlek som definierar maximal tillåten storlek för alla interna buffertar.
See also:
Example # 1: The following example shows how to set a memory limit when creating a new JPE…
Property: palette
Hämtar eller anger färgpaletten.
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
Hämtar eller anger upplösningsinställningarna.
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()
Skapar en medlemsvis klon av detta objekt.
Returns
| Typ | Beskrivning |
|---|---|
| ImageOptionsBase | En medlemsvis klon av detta objekt. |
Method: try_set_metadata(metadata)
try_set_metadata(metadata)
Försöker sätta en metadata-instans, om detta Image-instans stödjer och implementerar IImageMetadataFormat-instansen.
Parameters:
| Parameter | Typ | Beskrivning |
|---|---|---|
| metadata | IImageMetadataFormat | Metadata. |
Returns
| Typ | Beskrivning |
|---|---|
| bool | Sant, om IMetadataContainer‑instansen stöder och/eller implementerar IImageMetadataFormat‑instansen; annars falskt. |
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
# Skapa en BMP-bild 100 x 100 px.
with BmpImage(100, 100) as bmpImage:
# Den linjära gradienten från övre vänstra till nedre högra hörnet av bilden.
brush = LinearGradientBrush(Point(0, 0), Point(bmpImage.width, bmpImage.height),
Color.red,
Color.green)
# Fyll hela bilden med den linjära gradientpenseln.
gr = Graphics(bmpImage)
gr.fill_rectangle(brush, bmpImage.bounds)
# Hämta den närmaste 8-bitars färgpaletten som täcker så många pixlar som möjligt, så att en palettiserad bild
# är nästan visuellt omöjlig att skilja från en bmp utan palett
palette = ColorPaletteHelper.get_close_image_palette(bmpImage, 256)
# 8-bitars palett innehåller högst 256 färger.
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.")
# Utdata ser ut så här:
# Storleken på bilden med palett är 11078 byte.
# Storleken på bilden utan palett är 40054 byte.
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
# Laddar png-bild
sourceFilePath = "OriginalRings.png"
outputFilePath = "OriginalRingsOutput.png"
with Image.load(sourceFilePath) as image:
png_options = PngOptions()
png_options.progressive = True
# Använd indexerad färgtyp
png_options.color_type = PngColorType.INDEXED_COLOR
# Använd maximal komprimering
png_options.compression_level = 9
# Hämta den närmaste 8-bitars färgpaletten, som täcker så många pixlar som möjligt, så att en bild
# med palett är nästan visuellt omöjlig att skilja från en bild utan palett.
png_options.palette = ColorPaletteHelper.get_close_image_palette(
as_of(image, RasterImage), 256,
PaletteMiningMethod.HISTOGRAM)
image.save(outputFilePath, png_options);
}
# Utdatafilens storlek bör minskas avsevärt
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)
# Skapa BmpOptions
saveOptions = BmpOptions()
# Använd 8 bitar per pixel för att minska storleken på utdatafilen.
saveOptions.bits_per_pixel = 8
# Ställ in den närmaste 8-bitars färgpaletten som täcker det maximala antalet bildpixlar, så att en palettiserad bild
# är nästan visuellt omöjlig att skilja från en icke-paletiserad.
saveOptions.palette = ColorPaletteHelper.get_close_image_palette(rasterImage, 256)
# Spara utan komprimering.
# Du kan också använda RLE-8-komprimering för att minska storleken på den resulterande bilden.
saveOptions.compression = BitmapCompression.RGB
# Ställ in horisontell och vertikal upplösning till 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()
# Spara till en fil
createOptions.source = FileCreateSource(path_join(directory, "output.palette8bit.bmp"), False)
# Använd 8 bitar per pixel för att minska storleken på utdatafilen.
createOptions.bits_per_pixel = 8
# Ställ in den standard 8-bitars gråskala färgpaletten som täcker alla gråskalefärger.
# Om den bearbetade bilden bara innehåller gråskalefärger, så är dess palettiserade version
# är visuellt omöjlig att skilja från en icke-paletiserad.
createOptions.palette = ColorPaletteHelper.create_8_bit_grayscale(False)
# Spara utan komprimering.
# Du kan också använda RLE-8-komprimering för att minska storleken på den resulterande bilden.
createOptions.compression = BitmapCompression.RGB
# Ställ in horisontell och vertikal upplösning till 96 dpi.
createOptions.resolution_settings = ResolutionSetting(96.0, 96.0)
# Skapa en BMP-bild på 100 x 100 px och spara den till en fil.
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)
# Fyll bilden med ett gråskaleförlopp
graphics.fill_rectangle(gradientBrush, image.bounds)
image.save()
The following example shows how to set a memory limit when creating a new JPEG image. The memory limit is the maximum allowed size (in megabytes) for all internal buffers.
from os.path import join
from aspose.imaging import Image
from aspose.imaging.sources import FileCreateSource
from aspose.imaging.imageoptions import JpegOptions
from aspose.imaging.fileformats.jpeg import JpegCompressionMode
dir_: str = "c:\\aspose.imaging\\issues\\net\\3404\\"
# Ställer in en minnesgräns på 50 megabyte för målbilden som skapas
create_options = JpegOptions()
create_options.compression_type = JpegCompressionMode.PROGRESSIVE
create_options.buffer_size_hint = 50
create_options.source = FileCreateSource(join(dir_, "createdFile.jpg"), False)
with Aspose.Imaging.Image.create(create_options, 1000, 1000) as image:
# spara till samma plats
image.save()
