HTML JPG PDF XML APNG
Aspose.Imaging  per Python
BMP

Utilizza Python per la conversione delle immagini da EMF a BMP

Crea app Python per convertire immagini e foto da EMF a BMP tramite API server

Come convertire immagini e foto da EMF a BMP con Python

La conversione dei file immagine da un formato all’altro è un’attività comune incontrata da ogni grafico. L’efficienza e l’eccellenza nella conversione dei file non influiscono solo sulla velocità di completamento, ma svolgono anche un ruolo cruciale nella valutazione della qualità complessiva del lavoro. Per quanto riguarda le fonti delle immagini, spesso necessitano di trasformazione in formati alternativi più adatti alla stampa o alla distribuzione online. È probabile che un’immagine creata con un editor grafico sia in formato vettoriale. In tali casi, per la pubblicazione sul sito web, è necessario sottoporlo a rasterizzazione ed essere salvato in formato raster. Hai la possibilità di convertire l’immagine in un formato non compresso per una qualità superiore o salvarla in un formato compresso senza perdita di dati per ridurre al minimo le dimensioni del file. Per gli scenari in cui la riduzione delle dimensioni del file è obbligatoria, come nelle applicazioni dei siti Web, c’è la possibilità di conversione in formati di compressione con perdita. Algoritmi specializzati di compressione dei dati per le immagini possono ridurre significativamente le dimensioni del file mantenendo una qualità dell’immagine accettabile, garantendo un caricamento rapido delle immagini. Per convertire immagini e foto da EMF a BMP, 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 convertire EMF in BMP tramite Python

Gli sviluppatori possono caricare e convertire facilmente i file EMF in BMP in poche righe di codice.

  • Carica il file EMF con il metodo Image.Load
  • Crea e imposta l’istanza della sottoclasse richiesta di ImageOptionsBase (ad es. BmpOptions, PngOptions, ecc.)
  • Chiama il metodo Image.Save
  • Passa il percorso del file con l’estensione BMP e l’oggetto della classe ImageOptionsBase

Requisiti di sistema

Prima di eseguire il codice di esempio di conversione, assicurati di disporre dei seguenti prerequisiti.

  • Sistema operativo: Windows o Linux.
  • Ambiente di sviluppo: supporta .NET Core 7 e versioni successive, come Microsoft Visual Studio.

App gratuita per convertire EMF in BMP

  • Seleziona o trascina e rilascia l'immagine EMF
  • Scegli il formato e fai clic sul pulsante Converti
  • Fare clic sul pulsante Download per scaricare l'immagine BMP
*Caricando i tuoi file o utilizzando il nostro servizio accetti i nostri Termini di servizio e politica sulla riservatezza

Dai un’occhiata alle nostre dimostrazioni dal vivo per convertire EMF in BMP

Converti EMF in BMP - Python

from aspose.imaging import *
from aspose.imaging.fileformats.tiff.enums import *
from aspose.imaging.fileformats.jpeg2000 import *
from aspose.imaging.fileformats.png import *
from aspose.imaging.imageoptions import *
from aspose.pycore import 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
data_dir = templates_folder
def process_convertion():
import_formats, export_formats = get_available_image_formats()
for import_key, import_value in import_formats.items():
format_ext = import_key
input_file = os.path.join(templates_folder, f"template.{format_ext}")
if not os.path.exists(input_file):
continue
for export_key, export_value in export_formats.items():
output_file = os.path.join(templates_folder, f"convert-{format_ext}-to-{export_key}.{export_key}")
print("Processing conversion:" + output_file)
with Image.load(input_file) as image:
export_options = export_value.clone()
if is_assignable(image, VectorImage):
rasterization_options = import_value
rasterization_options.page_width = float(image.width)
rasterization_options.page_height = float(image.height)
export_options.vector_rasterization_options = rasterization_options
image.save(output_file, export_options)
if delete_output:
os.remove(output_file)
def get_available_image_formats():
obj_init = Jpeg2000Options()
obj_init.codec = Jpeg2000Codec.J2K
obj_init2 = Jpeg2000Options()
obj_init2.codec = Jpeg2000Codec.JP2
obj_init3 = PngOptions()
obj_init3.color_type = PngColorType.TRUECOLOR_WITH_ALPHA
obj_init4 = {}
obj_init4["bmp"] = BmpOptions()
obj_init4["gif"] = GifOptions()
obj_init4["dicom"] = DicomOptions()
obj_init4["jpg"] = JpegOptions()
obj_init4["jpeg"] = JpegOptions()
obj_init4["jpeg2000"] = Jpeg2000Options()
obj_init4["j2k"] = obj_init
obj_init4["jp2"] = obj_init2
obj_init4["png"] = obj_init3
obj_init4["apng"] = ApngOptions()
obj_init4["tiff"] = TiffOptions(TiffExpectedFormat.DEFAULT)
obj_init4["tif"] = TiffOptions(TiffExpectedFormat.DEFAULT)
obj_init4["tga"] = TgaOptions()
obj_init4["webp"] = WebPOptions()
obj_init4["ico"] = IcoOptions(FileFormat.PNG, 24)
raster_formats_that_support_export_and_import = obj_init4
obj_init5 = EmfOptions()
obj_init5.compress = True
obj_init6 = WmfOptions()
obj_init6.compress = True
obj_init7 = SvgOptions()
obj_init7.compress = True
obj_init8 = {}
obj_init8["emf"] = (EmfOptions(), EmfRasterizationOptions())
obj_init8["svg"] = (SvgOptions(), SvgRasterizationOptions())
obj_init8["wmf"] = (WmfOptions(), WmfRasterizationOptions())
obj_init8["emz"] = (obj_init5, EmfRasterizationOptions())
obj_init8["wmz"] = (obj_init6, WmfRasterizationOptions())
obj_init8["svgz"] = (obj_init7, SvgRasterizationOptions())
vector_formats_that_support_export_and_import = obj_init8
obj_init9 = DxfOptions()
obj_init9.text_as_lines = True
obj_init9.convert_text_beziers = True
obj_init10 = {}
obj_init10["psd"] = PsdOptions()
obj_init10["dxf"] = obj_init9
obj_init10["pdf"] = PdfOptions()
obj_init10["html"] = Html5CanvasOptions()
formats_only_for_export = obj_init10
obj_init11 = {}
obj_init11["djvu"] = None
obj_init11["dng"] = None
obj_init11["dib"] = None
formats_only_for_import = obj_init11
obj_init12 = {}
obj_init12["eps"] = EpsRasterizationOptions()
obj_init12["cdr"] = CdrRasterizationOptions()
obj_init12["cmx"] = CmxRasterizationOptions()
obj_init12["otg"] = OtgRasterizationOptions()
obj_init12["odg"] = OdgRasterizationOptions()
vector_formats_only_for_import = obj_init12
# Get total set of formats to what we can export images
export_formats = {k: v[0] for k, v in vector_formats_that_support_export_and_import.items()}
export_formats.update(formats_only_for_export)
export_formats.update(raster_formats_that_support_export_and_import)
# Get total set of formats that can be loaded
import_formats = {k : VectorRasterizationOptions() for k in formats_only_for_import}
import_formats.update(vector_formats_only_for_import)
import_formats.update({k : v[1] for k, v in vector_formats_that_support_export_and_import.items()})
return import_formats, export_formats
# run
process_convertion()

EMF Cos'è EMF Formato del file

Il formato metafile avanzato (EMF) memorizza le immagini grafiche indipendentemente dal dispositivo. I metafile di EMF comprendono record di lunghezza variabile in ordine cronologico che possono eseguire il rendering dell'immagine archiviata dopo l'analisi su qualsiasi dispositivo di output. Questi record a lunghezza variabile possono essere definizioni di oggetti racchiusi, comandi per il disegno e proprietà grafiche fondamentali per il rendering accurato dell'immagine. Quando un dispositivo apre un metafile EMF utilizzando il proprio ambiente grafico, le proporzioni, le dimensioni, i colori e altre proprietà grafiche dell'immagine originale rimangono le stesse indipendentemente dalla piattaforma del dispositivo di apertura.

Per saperne di più | EMF

BMP Cos'è BMP Formato del file

I file con estensione .BMP rappresentano file di immagine bitmap che vengono utilizzati per memorizzare immagini digitali bitmap. Queste immagini sono indipendenti dalla scheda grafica e sono anche chiamate formato file DIB (Device Independent Bitmap). Questa indipendenza serve allo scopo di aprire il file su più piattaforme come Microsoft Windows e Mac. Il formato file BMP può memorizzare dati come immagini digitali bidimensionali sia in formato monocromatico che a colori con varie profondità di colore.

Per saperne di più | BMP

Altre conversioni supportate

Usando Python, è possibile convertire facilmente diversi formati tra cui.

BMP (Immagine bitmap)
GIF (Formato di scambio grafico)
DICOM (Immagini e comunicazioni digitali)
JPG (Gruppo congiunto di esperti fotografici)
JPEG (Gruppo congiunto di esperti fotografici)
JP2 (JPEG 2000)
J2K (Immagine compressa Wavelet)
JPEG2000 (JPEG 2000)
PNG (Grafica di rete portatile)
APNG (Grafica di rete portatile animata)
PSD (Documento Photoshop)
DXF (Formato interscambio disegni, o formato scambio disegni,)
SVG (Grafica vettoriale scalabile)
TIFF (Formato immagine contrassegnato)
WEBP (Immagine web raster)
WMF (Metafile di Microsoft Windows)
PDF (Formato documento portatile (PDF))
HTML (Tela HTML5)
EMZ (Metafile avanzato compresso di Windows)
WMZ (Skin compressa di Windows Media Player)
TGA (Grafica Targa)
SVGZ (Versione compressa del file Scalable Vector Graphics (.SVG).)
CANVAS (Tela HTML5)
ICO (Icona di Windows)