Aspose.Medical DICOM a Converter di testo per .NET Knowledge Base
Come convertire molti file DICOM in un singolo array JSON

Come convertire molti file DICOM in un singolo array JSON

Questo tutorial dimostra come convertire più file DICOM in un singolo file JSON utilizzando C#. Questo approccio è ideale per gli ingegneri di dati che hanno bisogno di esportare i metadati DIKOM per strumenti di analisi, database, o pipeline dati.

I vantaggi di JSON Array Export

  • ** Il trattamento dei dati di Bulk**:- Importare più registri DICOM in database in una sola operazione.

  • *L’analisi è pronta:- I rassi JSON possono essere caricati direttamente in Python, Spark o archivi di dati.

    • Il risultato compatto *:- Un singolo file contenente tutti i metadati semplifica la gestione dei dati.

Prerequisiti: preparare l’ambiente

  • Inserisci Visual Studio o qualsiasi compatibile .NET IDE.
  • Creare un nuovo progetto di applicazione .NET 8 console.
  • Installare Aspose.Medical dal NuGet Package Manager.
  • Preparare una cartella contenente più file DICOM.

Guida passo dopo passo per convertire molti file DICOM in JSON Array

Passo 1: Installare Aspose.Medical

Aggiungi la biblioteca medica Aspose al tuo progetto utilizzando NuGet.

Install-Package Aspose.Medical

Passo 2: Includere gli spazi di nome necessari

Aggiungi riferimenti agli spazi di nome richiesti nel tuo codice.

using Aspose.Medical.Dicom;
using Aspose.Medical.Dicom.Serialization;

Passo 3: Caricare molti file DICOM

Caricare i file DICOM da una cartella in una collezione.

string inputFolder = @"C:\DicomStudies";
string[] dicomPaths = Directory.GetFiles(inputFolder, "*.dcm");

List<DicomFile> dicomFiles = new();
foreach (string path in dicomPaths)
{
    dicomFiles.Add(DicomFile.Open(path));
}

Passo 4: Extract Dataset Array

Costruisci una serie di oggetti Dataset dai file caricati.

Dataset[] datasets = dicomFiles
    .Select(dcm => dcm.Dataset)
    .ToArray();

Passo 5: Serializzare a JSON Array

Utilizzo DicomJsonSerializer.Serialize con il dataset array.

string jsonArray = DicomJsonSerializer.Serialize(datasets, writeIndented: true);

Passo 6: Salva il JSON Array

Salva l’array JSON in un file.

File.WriteAllText("dicom_studies.json", jsonArray);
Console.WriteLine($"Exported {datasets.Length} DICOM datasets to JSON array.");

Esempio di codice completo

Ecco un esempio completo che dimostra come convertire più file DICOM in una serie JSON:

using Aspose.Medical.Dicom;
using Aspose.Medical.Dicom.Serialization;

string inputFolder = @"C:\DicomStudies";
string outputFile = "dicom_studies.json";

// Get all DICOM files
string[] dicomPaths = Directory.GetFiles(inputFolder, "*.dcm");
Console.WriteLine($"Found {dicomPaths.Length} DICOM files.");

// Load all files
List<DicomFile> dicomFiles = new();
foreach (string path in dicomPaths)
{
    try
    {
        dicomFiles.Add(DicomFile.Open(path));
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Skipping invalid file: {Path.GetFileName(path)}");
    }
}

// Build dataset array
Dataset[] datasets = dicomFiles
    .Select(dcm => dcm.Dataset)
    .ToArray();

// Serialize to JSON array
string jsonArray = DicomJsonSerializer.Serialize(datasets, writeIndented: true);

// Save to file
File.WriteAllText(outputFile, jsonArray);

Console.WriteLine($"Successfully exported {datasets.Length} datasets to {outputFile}");

Esempio di JSON Array Output

Il prodotto JSON array appare così:

[
  {
    "00080005": { "vr": "CS", "Value": ["ISO_IR 100"] },
    "00100010": { "vr": "PN", "Value": [{ "Alphabetic": "DOE^JOHN" }] },
    "00100020": { "vr": "LO", "Value": ["12345"] }
  },
  {
    "00080005": { "vr": "CS", "Value": ["ISO_IR 100"] },
    "00100010": { "vr": "PN", "Value": [{ "Alphabetic": "SMITH^JANE" }] },
    "00100020": { "vr": "LO", "Value": ["67890"] }
  }
]

Il trattamento dei big data con LINQ

Per una migliore gestione della memoria con grandi set di dati, utilizzare le proiezioni LINQ:

using Aspose.Medical.Dicom;
using Aspose.Medical.Dicom.Serialization;

string inputFolder = @"C:\LargeDicomArchive";
string outputFile = "large_export.json";

// Process files lazily to manage memory
Dataset[] datasets = Directory.GetFiles(inputFolder, "*.dcm")
    .Select(path => 
    {
        try
        {
            return DicomFile.Open(path).Dataset;
        }
        catch
        {
            return null;
        }
    })
    .Where(ds => ds != null)
    .ToArray()!;

string jsonArray = DicomJsonSerializer.Serialize(datasets, writeIndented: true);
File.WriteAllText(outputFile, jsonArray);

Console.WriteLine($"Exported {datasets.Length} datasets.");

Aggiungi il rapporto di progresso

Per i big batch, aggiungere il rapporto di progresso:

using Aspose.Medical.Dicom;
using Aspose.Medical.Dicom.Serialization;

string inputFolder = @"C:\DicomStudies";
string[] dicomPaths = Directory.GetFiles(inputFolder, "*.dcm");

List<Dataset> datasets = new();
int processed = 0;
int total = dicomPaths.Length;

foreach (string path in dicomPaths)
{
    try
    {
        DicomFile dcm = DicomFile.Open(path);
        datasets.Add(dcm.Dataset);
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error: {Path.GetFileName(path)} - {ex.Message}");
    }
    
    processed++;
    if (processed % 100 == 0 || processed == total)
    {
        Console.WriteLine($"Progress: {processed}/{total} ({processed * 100 / total}%)");
    }
}

string jsonArray = DicomJsonSerializer.Serialize(datasets.ToArray(), writeIndented: true);
File.WriteAllText("export.json", jsonArray);

Console.WriteLine($"Export complete: {datasets.Count} datasets.");

Importare JSON Array in strumenti di analisi

Un esempio di Python 

import json
import pandas as pd

# Load the exported JSON array
with open('dicom_studies.json', 'r') as f:
    dicom_data = json.load(f)

# Convert to DataFrame for analysis
df = pd.json_normalize(dicom_data)
print(df.head())

Caricamento in MongoDB 

// Using mongoimport
// mongoimport --db medical --collection studies --jsonArray --file dicom_studies.json

Le considerazioni della memoria

Quando si lavora con grandi set di dati:

  • Processo in Batchi: Dividere i file in batchi di 100-500 file.
  • Stream Output: utilizza la serializzazione basata sul flusso per i rami molto grandi.
  • Dispose File: Assicurarsi che gli oggetti di DicomFile siano smaltiti dopo l’estrazione dei set di dati.
// Batch processing example
int batchSize = 100;
string[] allFiles = Directory.GetFiles(inputFolder, "*.dcm");
int batchNumber = 0;

for (int i = 0; i < allFiles.Length; i += batchSize)
{
    string[] batch = allFiles.Skip(i).Take(batchSize).ToArray();
    Dataset[] datasets = batch
        .Select(path => DicomFile.Open(path).Dataset)
        .ToArray();
    
    string batchJson = DicomJsonSerializer.Serialize(datasets, writeIndented: true);
    File.WriteAllText($"batch_{batchNumber++}.json", batchJson);
}

Informazioni aggiuntive

  • Il formato JSON è ideale per l’importazione di massa in database NoSQL.
  • Considerare la compressione di grandi file JSON per l’efficienza dello storage.
  • Per scenari di streaming, considerare l’utilizzo del formato NDJSON (newline-delimited JSON) invece.

conclusione

Questo tutorial ti ha mostrato come convertire più file DICOM in un singolo file JSON in C# utilizzando Aspose.Medical.Questo approccio consente efficiente esportazione di dati di massa per le analisi, le importazioni di database e l’integrazione del pipeline dei dati.

 Italiano