PPTX DOCX XLSX PDF ODP
Aspose.Imaging  per Python
DICOM

Utilizza Python per la regolazione delle immagini DICOM

Crea app Python per modificare immagini e foto DICOM tramite API server

Come regolare immagini e foto DICOM con Python

Durante l’acquisizione delle immagini possono verificarsi errori dovuti a impostazioni errate della fotocamera. Anche un’illuminazione incontrollata può influire sui risultati e anche le fotografie professionali possono presentare imperfezioni. Tuttavia, in tali scenari, esiste un metodo per migliorare l’immagine utilizzando gli strumenti software forniti dalla libreria Python. Hai la possibilità di ottimizzare la luminosità, il contrasto e il bilanciamento del colore dell’immagine. Ad esempio, se una foto appare eccessivamente scura, aumentando la luminosità si illumineranno le regioni più scure, svelando dettagli che precedentemente erano oscurati dalle ombre. Se la tua immagine presenta dominanti di colore indesiderate a causa dell’illuminazione artificiale, puoi correggerla utilizzando la funzione di regolazione della gamma di colori. Per eseguire queste modifiche sui file DICOM, puoi utilizzare 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 modificare DICOM tramite Python

Hai bisogno di aspose-imaging-python-net per provare il seguente flusso di lavoro nel tuo ambiente.

  • Carica file DICOM con il metodo Image.Load
  • Regola le immagini;
  • 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.
 

Regola le immagini di DICOM - Python

from aspose.imaging import *
from aspose.imaging.fileformats.bmp import *
from aspose.imaging.fileformats.dicom import *
from aspose.imaging.fileformats.emf import *
from aspose.imaging.fileformats.jpeg import *
from aspose.imaging.fileformats.jpeg2000 import *
from aspose.imaging.fileformats.png import *
from aspose.imaging.fileformats.psd import *
from aspose.imaging.fileformats.tiff.enums import *
from aspose.imaging.imagefilters.filteroptions import *
from aspose.imaging.imageoptions import *
from aspose.imaging.masking import *
from aspose.imaging.masking.options import *
from aspose.imaging.masking.result import *
from aspose.imaging.sources import *
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 adjust_gamma_rgb():
# https://apireference.aspose.com/imaging/python-net/aspose.imaging.rasterimage/adjustgamma
filter_images(lambda image: image.adjust_gamma(5, 0.1, 0.1), "adjustgammargb")
def adjust_gamma():
filter_images(lambda image: image.adjust_gamma(3), "adjustgamma")
def adjust_contrast():
filter_images(lambda image: image.adjust_contrast(50), "adjustcontrast")
def adjust_brightness():
filter_images(lambda image: image.adjust_brightness(100), "adjustbrightness")
def filter_images(do_filter, filter_name):
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("tif")
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 = []
all_formats.extend(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"{filter_name}_{format_ext}.png")
print(format_ext)
# explicit type casting from Image to RasterImage
with as_of(Image.load(input_file), RasterImage) as image:
do_filter(image)
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:
# for loop
page_index = 0
for page in multi_page.pages:
file_name = f"{filter_name}_page{page_index}_{format_ext}.png"
page.save(os.path.join(templates_folder + file_name), PngOptions())
# delete an output file
delete_file(os.path.join(templates_folder + file_name))
page_index += 1
else:
image.save(output_file, PngOptions())
# delete an output file
delete_file(output_file)
# delete a rasterized file
if is_vector_format:
delete_file(input_file)
def delete_file(file):
if delete_output:
os.remove(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
# call one of the functions
adjust_brightness()
#adjust_contrast()
#adjust_gamma()
#adjust_gamma_rgb()
 
  • 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.

    Modifica i DICOM tramite l’app online

    Modifica i documenti DICOM visitando il nostro sito web di demo live . La demo dal vivo ha i seguenti vantaggi

      Non è necessario scaricare o configurare nulla
      Non c'è bisogno di scrivere alcun codice
      Carica i tuoi file DICOM e premi il pulsante "Regola ora".
      Ottieni immediatamente il link per il download del file risultante

    DICOM Cos'è DICOM Formato del file

    DICOM è l'acronimo di Digital Imaging and Communications in Medicine e appartiene al campo dell'informatica medica. DICOM è la combinazione di definizione del formato file e protocollo di comunicazione di rete. DICOM utilizza l'estensione .DCM. .DCM esiste in due diversi formati, ovvero il formato 1.x e il formato 2.x. DCM Format 1.x è inoltre disponibile in due versioni normale ed estesa. DICOM viene utilizzato per l'integrazione di dispositivi di imaging medico come stampanti, server, scanner, ecc. di vari fornitori e contiene anche i dati di identificazione di ciascun paziente per l'unicità. I file DICOM possono essere condivisi tra due parti se sono in grado di ricevere dati di immagine in formato DICOM. La parte di comunicazione di DICOM è il protocollo del livello dell'applicazione e utilizza TCP/IP per comunicare tra entità. I protocolli HTTP e HTTPS vengono utilizzati per i servizi Web di DICOM. Le versioni supportate dai servizi Web sono 1.0, 1.1, 2 o successive.

    Per saperne di più

    Altri formati di regolazione supportati

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

    APNG (Grafica di rete portatile animata)
    BMP (Immagine bitmap)
    ICO (Icona di Windows)
    JPG (Gruppo congiunto di esperti fotografici)
    JPEG (Gruppo congiunto di esperti fotografici)
    DIB (Bitmap indipendente dal dispositivo)
    DJVU (Formato grafico)
    DNG (Immagine della fotocamera digitale)
    EMF (Formato Metafile migliorato)
    EMZ (Metafile avanzato compresso di Windows)
    GIF (Formato di scambio grafico)
    JP2 (JPEG 2000)
    J2K (Immagine compressa Wavelet)
    PNG (Grafica di rete portatile)
    TIFF (Formato immagine contrassegnato)
    TIF (Formato immagine contrassegnato)
    WEBP (Immagine web raster)
    WMF (Metafile di Microsoft Windows)
    WMZ (Skin compressa di Windows Media Player)
    TGA (Grafica Targa)
    SVG (Grafica vettoriale scalabile)
    EPS (Linguaggio PostScript incapsulato)
    CDR (Immagine di disegno vettoriale)
    CMX (Immagine di scambio di Corel)
    OTG (Standard OpenDocument)
    ODG (Formato Apache OpenOffice Draw)