Aspose.Medical DICOM para Converter de texto para .NET Knowledge Base
Cómo convertir varios archivos DICOM en un solo array JSON

Cómo convertir varios archivos DICOM en un solo array JSON

Este tutorial demuestra cómo convertir varios archivos DICOM en un solo array JSON utilizando C#. Este enfoque es ideal para los ingenieros de datos que necesitan exportar metadatos DIKOM para herramientas de análisis, bases de Datos o tuberías de información.

Beneficios de JSON Array Export

  • ** Procesamiento de datos de Bulk**:- Importar varios registros DICOM en bases de datos en una sola operación.

  • Los analistas están listos:- Los rasgos JSON se pueden cargar directamente en Python, Spark o almacenes de datos.

    • Página de salida compacta:- El archivo único que contiene todos los metadatos simplifica la gestión de datos.

Requisitos: Preparación del medio ambiente

  • Instalar Visual Studio o cualquier compatible .NET IDE.
  • Crea un nuevo proyecto de aplicación .NET 8 consola.
  • Instalar Aspose.Medical desde el NuGet Package Manager.
  • Preparar una carpeta que contenga varios archivos DICOM.

Guía paso a paso para convertir varios archivos DICOM en JSON Array

Paso 1: Instalar Aspose.Medical

Añade la biblioteca de Aspose.Medical a su proyecto utilizando NuGet.

Install-Package Aspose.Medical

Paso 2: Incluir los espacios de nombre necesarios

Añade las referencias a los espacios de nombre requeridos en su código.

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

Paso 3: Cargar varios archivos DICOM

Cargar archivos DICOM de una carpeta en una colección.

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

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

Paso 4: Extracción de Dataset Array

Crea una serie de objetos de Dataset de los archivos cargados.

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

Paso 5: Serializar con JSON Array

Uso DicomJsonSerializer.Serialize con el arreglo de datos.

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

Paso 6: Salva el array JSON

Salva el array JSON a un archivo.

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

Exemplos de código completo

Aquí hay un ejemplo completo que demuestra cómo convertir varios archivos DICOM en 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}");

Descripción de JSON Array Output

La salida de JSON array parece así:

[
  {
    "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"] }
  }
]

Procesar grandes datos con LINQ

Para una mejor gestión de la memoria con grandes conjuntos de datos, utilice proyecciones 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.");

Añadir informes de progreso

Para grandes batallas, añade el informe de progreso:

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.");

Importación de JSON Array en herramientas de análisis

El ejemplo de 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())

Descargar en MongoDB 

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

Consideraciones de memoria

Cuando trabajamos con grandes conjuntos de datos:

  • Proceso en Batches: Dividir los archivos en batches de 100-500 ficheros.
  • Expuesto de corriente: Utilice la serificación basada en el flujo para arrases muy grandes.
  • Disponer archivos: Asegúrese de que los objetos DicomFile se eliminan después de extraer conjuntos de datos.
// 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);
}

Información adicional

  • El formato de array JSON es ideal para las importaciones masivas en las bases de datos NoSQL.
  • Considere comprimir grandes archivos JSON para la eficiencia del almacenamiento.
  • Para los escenarios de streaming, considere utilizar el formato NDJSON (newline-delimited JSON) en lugar.

Conclusión

Este tutorial le ha mostrado cómo convertir varios ficheros DICOM en una única array JSON en C# utilizando Aspose.Medical.Este enfoque permite una exportación eficiente de datos en gran medida para análisis, importaciones de database, e integración de tubo de información.

 Español