Utilizza Python per immagini in scala di grigi JPG
Crea app Python per immagini e foto in scala di grigi JPG tramite API server
Come scalare i grigi di immagini e foto in formato JPG con Python
I colori vivaci sono generalmente associati come l’essenza di splendide foto. Ma cosa succede se la possibilità di stampare a colori non è un’opzione? In tali scenari, nasce la necessità di trasformare la foto a colori in scala di grigi e, sorprendentemente, ciò non ne compromette necessariamente l’impatto. Spesso, la conversione dal colore alla scala di grigi è di per sé una tecnica artistica, che aumenta il fascino del tuo design. Il processo, abbinato all’eliminazione delle informazioni sul colore, può fungere da complice, accentuando i dettagli dell’immagine, facendo risaltare la trama delle superfici e orchestrando una sinfonia visiva tra luce e ombra, creando così un effetto visivo distintivo. Per convertire le immagini JPG in scala di grigi, utilizzeremo Aspose.Imaging per Python tramite .NET API che è un’API di manipolazione e conversione delle immagini ricca di funzionalità, potente e facile da usare per la piattaforma Python. Puoi installarlo usando il seguente comando dal tuo comando di sistema.
La riga di comando del sistema
>> pip install aspose-imaging-python-net
Passaggi per scalare i grigi JPG tramite Python
Hai bisogno di aspose-imaging-python-net per provare il seguente flusso di lavoro nel tuo ambiente.
- Carica file JPG con il metodo Image.Load
- Immagini in scala di grigi;
- Salva l’immagine compressa su disco nel formato supportato da Aspose.Imaging
Requisiti di sistema
Aspose.Imaging per Python è supportato su tutti i principali sistemi operativi. Assicurati solo di avere i seguenti prerequisiti.
- Microsoft Windows/Linux con .NET Core Runtime.
- Gestore di pacchetti Python e PyPi.
Immagini in scala di grigi JPG - Python
from aspose.imaging import RasterImage, Image, IMultipageImage | |
from aspose.imaging.imageoptions import PngOptions | |
from aspose.pycore import as_of, is_assignable | |
import os | |
if 'TEMPLATE_DIR' in os.environ: | |
templates_folder = os.environ['TEMPLATE_DIR'] | |
else: | |
templates_folder = r"C:\Users\USER\Downloads\templates" | |
delete_output = 'SAVE_OUTPUT' not in os.environ | |
def delete_file(file): | |
if delete_output: | |
os.remove(file) | |
def grayscale_images(): | |
obj_init = [] | |
obj_init.append("jpg") | |
obj_init.append("png") | |
obj_init.append("bmp") | |
obj_init.append("apng") | |
obj_init.append("dicom") | |
obj_init.append("jp2") | |
obj_init.append("j2k") | |
obj_init.append("tga") | |
obj_init.append("webp") | |
obj_init.append("tiff") | |
obj_init.append("gif") | |
obj_init.append("ico") | |
raster_formats = obj_init | |
obj_init2 = [] | |
obj_init2.append("svg") | |
obj_init2.append("otg") | |
obj_init2.append("odg") | |
obj_init2.append("eps") | |
obj_init2.append("wmf") | |
obj_init2.append("emf") | |
obj_init2.append("wmz") | |
obj_init2.append("emz") | |
obj_init2.append("cmx") | |
obj_init2.append("cdr") | |
vector_formats = obj_init2 | |
all_formats = raster_formats | |
all_formats.extend(vector_formats) | |
for format_ext in all_formats: | |
input_file = os.path.join(templates_folder, f"template.{format_ext}") | |
if not os.path.exists(input_file): | |
continue | |
is_vector_format = format_ext in vector_formats | |
if is_vector_format: | |
input_file = rasterize_vector_image(format_ext, input_file) | |
output_file = os.path.join(templates_folder, f"grayscale_{format_ext}.png") | |
print(f"Processing {format_ext}") | |
# explicit type casting from Image to RasterImage | |
with as_of(Image.load(input_file), RasterImage) as image: | |
# Additional code examples can be found at | |
# https://apireference.aspose.com/imaging/python-net/aspose.imaging/rasterimage/methods/grayscale | |
image.grayscale() | |
multi_page = None | |
# if image implements an IMultipageImage interface | |
if is_assignable(image, IMultipageImage): | |
multi_page = as_of(image, IMultipageImage) | |
if multi_page is not None and multi_page.page_count > 1: | |
page_index = 0 | |
for page in multi_page.pages: | |
file_name = f"grayscale_page{page_index}_{format_ext}.png" | |
page.save(templates_folder + file_name, PngOptions()) | |
delete_file(templates_folder + file_name) | |
page_index += 1 | |
else: | |
image.save(output_file, PngOptions()) | |
delete_file(output_file) | |
if is_vector_format: | |
delete_file(input_file) | |
def rasterize_vector_image(format_ext, input_file): | |
output_file = os.path.join(templates_folder, f"rasterized.{format_ext}.png") | |
with Image.load(input_file) as image: | |
image.save(output_file, PngOptions()) | |
return output_file | |
grayscale_images() |
Informazioni su Aspose.Imaging per l'API Python
Aspose.Imaging API è una soluzione di elaborazione delle immagini per creare, modificare, disegnare o convertire immagini (foto) all’interno delle applicazioni. Offre: elaborazione delle immagini multipiattaforma, incluse, a titolo esemplificativo ma non esaustivo, conversioni tra vari formati di immagine (inclusa elaborazione uniforme di immagini multipagina o multiframe), modifiche come disegnare, lavorare con primitive grafiche, trasformazioni (ridimensiona, ritaglia, capovolgi e ruota , binarizzazione, scala di grigi, regolazione), funzionalità avanzate di manipolazione delle immagini (filtro, dithering, mascheratura, raddrizzatura) e strategie di ottimizzazione della memoria. È una libreria autonoma e non dipende da alcun software per le operazioni sulle immagini. È possibile aggiungere facilmente funzionalità di conversione delle immagini ad alte prestazioni con API native all’interno dei progetti. Si tratta di API locali private al 100% e le immagini vengono elaborate sui tuoi server.Scala di grigi JPGs tramite l’app online
Documenti in scala di grigi JPG visitando il nostro sito web demo live . La demo dal vivo ha i seguenti vantaggi
JPG Cos'è JPG Formato del file
Un JPEG è un tipo di formato immagine che viene salvato utilizzando il metodo di compressione con perdita di dati. L'immagine di output, come risultato della compressione, è un compromesso tra la dimensione della memoria e la qualità dell'immagine. Gli utenti possono regolare il livello di compressione per ottenere il livello di qualità desiderato riducendo allo stesso tempo le dimensioni dello storage. La qualità dell'immagine viene influenzata in modo trascurabile se all'immagine viene applicata la compressione 10:1. Maggiore è il valore di compressione, maggiore è il degrado della qualità dell'immagine.
Per saperne di piùAltri formati in scala di grigi supportati
Usando Python, è possibile scalare facilmente diversi formati di grigio tra cui.