Ritagliare un’immagine ed esportarla in più formati è una necessità comune quando si creano miniature, anteprime o risorse personalizzate. Questa guida dimostra come eseguire tale operazione utilizzando Aspose.Imaging for Python e la classe RasterImageExporter, concentrandosi sulla parola chiave ritagliare ed esportare immagini in Python.

Punti chiave

  • RasterImageExporter può ritagliare un rettangolo e scrivere il risultato in qualsiasi formato immagine supportato.
  • Lo stesso rettangolo di ritaglio può essere riutilizzato in decine di formati senza ricaricare l’immagine di origine.
  • Verificare le dimensioni dell’immagine salvata garantisce che l’operazione di ritaglio sia riuscita.
  • Clonare gli oggetti delle opzioni di salvataggio evita effetti collaterali tra formati.
  • Una licenza temporanea consente la piena funzionalità mentre si valuta l’API.

Perché ritagliare ed esportare le immagini

Gli sviluppatori spesso hanno bisogno di una singola regione ritagliata da un’immagine, ma devono fornire quella regione in diversi formati di file per varie piattaforme. Prima di questa funzionalità, avresti dovuto caricare, ritagliare e salvare l’immagine separatamente per ogni formato, aumentando il carico di I/O e CPU. RasterImageExporter semplifica il flusso di lavoro applicando lo stesso rettangolo di ritaglio a ogni formato di output in un unico ciclo, risparmiando tempo e riducendo la complessità del codice.

Introduzione a Aspose.Imaging per Python

Per prima cosa, installa il pacchetto Aspose.Imaging usando pip:

pip install aspose-imaging-python-net

Per una documentazione dettagliata, visita la pagina del prodotto. La libreria funziona in qualsiasi ambiente Python che supporta l’integrazione .NET tramite Python.NET.

Come ritagliare ed esportare immagini in più formati

Di seguito è un esempio completo e autonomo che carica un set di immagini di test, definisce un rettangolo di ritaglio e salva la regione ritagliata in undici formati diversi.

Il seguente esempio mostra come ritagliare un rettangolo ed esportare il risultato in più formati utilizzando Python.

import os
from aspose.imaging import Image, Rectangle
from aspose.imaging.imageoptions import *
from aspose.imaging.fileformats.tiff.enums import TiffExpectedFormat

base_dir = "testdata"
out_dir = os.path.join(base_dir, "output")

if not os.path.exists(out_dir):
    os.mkdir(out_dir)

files = [
    "decHex_16Bpp555.bmp",
    "2086.gif",
    "3.jpg",
    "1.png",
    "bi_CCITT3_2d.tif",
    "light.ico",
    "Input.jp2",
    "ExifChunk.webp",
    "0008.DCM",
    "src-base-indexed.tga",
    "BigTiff.tiff.tiff"
]

save_exts = ["bmp", "gif", "jpeg", "png", "tiff", "ico", "jp2", "webp", "dicom", "tga", "bigtiff"]
save_options = [
    BmpOptions(),
    GifOptions(),
    JpegOptions(),
    PngOptions(),
    TiffOptions(TiffExpectedFormat.TIFF_DEFLATE_RGB),
    IcoOptions(),
    Jpeg2000Options(),
    WebPOptions(),
    DicomOptions(),
    TgaOptions(),
    BigTiffOptions(TiffExpectedFormat.TIFF_DEFLATE_RGB)
]

assert len(files) == len(save_exts)
assert len(files) == len(save_options)

# Define the Clipping Rectangle: (X, Y, Width, Height)
out_rect = Rectangle(10, 15, 100, 100)
error_list = []
for file in files:
    file_path = os.path.join(base_dir, file)
    # Load the source image once
    with Image.load(file_path) as image:
        for i in range(len(save_exts)):
            out_file = os.path.join(out_dir, file + "_clipped." + save_exts[i])
            # Clone the format‑specific options and apply the clipping rectangle
            image.save(out_file, save_options[i].clone(), out_rect)
            # Verify that the saved image has the expected size
            can_remove = True
            with Image.load(out_file) as test_image:
                if out_rect.size != test_image.size:
                    can_remove = False
                    error_list.append(
                        "Sizes (exp = {0}, real = {1}) are not equal! Input file: {2}, Output file: {3}".format(
                            out_rect.size, test_image.size, file, out_file))
            if can_remove:
                os.remove(out_file)

if error_list:
    error_text = "\n".join(error_list)
    print(error_text)
    raise AssertionError(error_text)

# Clean up the Temporary Directory
os.rmdir(out_dir)

Spiegazione dei passaggi chiave

  1. Impostare le directory – Lo script crea una cartella output per memorizzare i file ritagliati temporanei.
  2. Preparare gli elenchi di file – files contiene i nomi delle immagini di origine, mentre save_exts e save_options associano ogni file a un formato di destinazione e al relativo oggetto di opzioni.
  3. Definire il rettangolo di ritaglio – Rectangle(10, 15, 100, 100) specifica la regione da estrarre (x=10, y=15, larghezza=100, altezza=100).
  4. Caricare l’immagine di origine – Image.load(file_path) apre la sorgente una sola volta, riducendo le operazioni I/O.
  5. Salvare con ritaglio – image.save(out_file, save_options[i].clone(), out_rect) scrive la regione ritagliata nel formato appropriato. La chiamata clone() garantisce che ogni formato ottenga un’istanza di opzioni indipendente.
  6. Convalidare le dimensioni dell’output – Dopo ogni salvataggio, lo script ricarica il file di output e verifica che test_image.size corrisponda alle dimensioni del rettangolo, garantendo che il ritaglio sia riuscito.
  7. Pulizia – I file verificati con successo vengono rimossi e, infine, la directory temporanea viene eliminata.

Conclusione

Utilizzando RasterImageExporter di Aspose.Imaging, è possibile ritagliare una regione rettangolare una sola volta ed esportarla in uno qualsiasi dei formati immagine supportati in un’unica operazione. Questo approccio riduce il caricamento ridondante, semplifica il codice e garantisce un output coerente tra i formati.

FAQs

  1. RasterImageExporter può ritagliare immagini di qualsiasi formato? Sì, supporta il ritaglio per tutti i formati elencati nell’array delle opzioni di salvataggio, come BMP, GIF, JPEG, PNG, TIFF, ICO, JP2, WebP, DICOM, TGA e BigTIFF.

  2. Devo specificare il formato di output quando chiamo save? Il formato viene dedotto dall’estensione del file fornita; l’oggetto save‑options corrispondente definisce le impostazioni specifiche del formato.

  3. Cosa succede se il rettangolo di ritaglio supera le dimensioni dell’immagine sorgente?
    Viene generata un’ArgumentOutOfRangeException, quindi è necessario convalidare il rettangolo rispetto a image.size prima di salvare.

  4. È necessario clonare le opzioni di salvataggio per ogni iterazione? Il cloning crea una nuova istanza di opzioni per ogni formato, evitando effetti collaterali quando lo stesso oggetto viene riutilizzato.

  5. Come posso verificare che l’immagine ritagliata abbia le dimensioni previste? Ricarica il file salvato con Image.load e confronta la sua proprietà .size con quella originale Rectangle.size.

  6. Ho bisogno di una licenza commerciale per il clipping? Il clipping funziona con una licenza temporanea; ottieni una licenza completa per l’uso in produzione tramite la pagina della licenza temporanea.

Ottieni una licenza gratuita e scopri di più

Inizia a sperimentare con la funzionalità completa richiedendo una licenza temporanea: https://purchase.aspose.com/temporary-license/

Vedi anche