Aspose.Medical DICOM a Text Converter per a la base de coneixements .NET
Com convertir múltiples arxius DICOM en un únic arreu JSON

Com convertir múltiples arxius DICOM en un únic arreu JSON

Aquest tutorial demostra com convertir múltiples fitxers DICOM en una sola aranya JSON utilitzant C#. Aquesta aproximació és ideal per als enginyers de dades que necessiten exportar metadades d’ADCOM per a eines d’anàlisi, bases de datos o pipelines de données.

Els beneficis de JSON Array Export

    • El tractament de dades de l’empresa *:- Importar múltiples registres DICOM en bases de dades en una sola operació.

  • Anàlisis preparats *:- Els arrels de JSON es poden carregar directament a Python, Spark o emmagatzems de dades.

    • Extensió compacta *- Un arxiu únic que conté totes les metadades simplifica la gestió de dades.

Previsió: Preparar el medi ambient

  • Instal·lació de Visual Studio o qualsevol compatible .NET IDE.
  • Crear un nou projecte d’aplicació .NET 8 consola.
  • Instal·la Aspose.Medical des del NuGet Package Manager.
  • Preparar una carpeta que conté múltiples fitxers DICOM.

Guia de pas a pas per convertir múltiples arxius DICOM a JSON Array

Pas 1: Instal·lació Aspose.Medical

Afegeix la biblioteca d’Aspose.Medical al teu projecte utilitzant NuGet.

Install-Package Aspose.Medical

Pas 2: Incloure els espais de nom necessaris

Afegeix referències als espais de nom requerits en el teu codi.

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

Pas 3: Carregar múltiples arxius DICOM

Carregar els arxius DICOM d’una pasta a una col·lecció.

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

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

Pas 4: Extracció de Dataset Array

Construir una sèrie d’objectes de Dataset des dels arxius carregats.

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

Pas 5: Serialitzar amb JSON Array

Use DicomJsonSerializer.Serialize amb el Dataset Array.

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

Pas 6: Salvar el JSON Array

Salvar l’arreu JSON a un fitxer.

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

Exemple de codi complet

Aquí teniu un exemple complet que demostra com convertir múltiples arxius DICOM en un arreu 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}");

Exemple de JSON Array Output

L’arrel de sortida JSON sembla així:

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

Tractament de grans dades amb LINQ

Per a una millor gestió de la memòria amb grans set de dades, utilitzeu projeccions 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.");

Addició de reportatge de progrés

Per a grans batxes, afegir reportatge de progrés:

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ó de JSON Array en eines d’anàlisi

Exemple 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())

Descarregar a MongoDB 

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

Consideracions de memòria

Quan treballem amb grans grups de dades:

  • Procés en batxes: Divideix els arxius en setges de 100-500 arsipes.
  • Stream Output: Utilitza la serialització basada en el flux per a arrels molt grans.
  • Disposar arxius: Assegureu-vos que els objectes DicomFile s’eliminen després de l’extracció de set de dades.
// 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ó addicional

  • El format d’arrel JSON és ideal per a les importacions massives en bases de dades de NoSQL.
  • Considera compressar grans arxius JSON per a l’eficiència d’emmagatzematge.
  • Per a escenaris de streaming, considereu utilitzar el format NDJSON (newline-delimited JSON) en lloc.

Conclusió

Aquest tutorial t’ha mostrat com convertir múltiples fitxers DICOM en una sola aranya JSON en C# utilitzant Aspose.Medical. Aquest enfocament permet l’exportació de dades en massa eficient per a les anàlisis, les importacions de bases de datos i la integració del pipeline.

 Català