Aspose.Medical DICOM zum Textkonverter für .NET Knowledge Base
Wie man mehrere DICOM-Dateien in eine einzige JSON-Array umwandelt

Wie man mehrere DICOM-Dateien in eine einzige JSON-Array umwandelt

Dieses Tutorial zeigt, wie man mehrere DICOM-Dateien in eine einzige JSON-Reihe mit C# umwandelt.Dieser Ansatz ist ideal für Dateningenieure, die Metadaten für Analyse-Tools, Datenbanken oder Datenpipe exportieren müssen.

Vorteile von JSON Array Export

  • *Bulk Datenverarbeitung- Importieren Sie mehrere DICOM-Dokumente in Datenbanken in einer einzelnen Operation.

  • „Analytics Ready“- JSON-Arays können direkt in Python, Spark oder Datenlager geladen werden.

    • Kompakte Ausgabe *:- Eine einzelne Datei, die alle Metadaten enthält, vereinfacht das Datenmanagement.

Voraussetzungen: Umwelt vorbereiten

  • Installieren Sie Visual Studio oder eine kompatible .NET IDE.
  • Erstellen Sie ein neues .NET 8-Konsole-Anwendungsprojekt.
  • Installieren Sie Aspose.Medical vom NuGet Package Manager.
  • Bereiten Sie eine Folie mit mehreren DICOM-Dateien vor.

Schritt für Schritt Guide zum Umwandeln von mehreren DICOM-Dateien in JSON Array

Schritt 1: Installieren Aspose.Medical

Fügen Sie die Aspose.Medical Bibliothek zu Ihrem Projekt mit NuGet hinzu.

Install-Package Aspose.Medical

Schritt 2: Inkludieren Sie notwendige Namenräume

Fügen Sie Referenzen zu den erforderlichen Namenräumen in Ihrem Code hinzu.

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

Schritt 3: Laden Sie Multiple DICOM-Dateien

Laden Sie DICOM-Dateien aus einem Ordner in eine Sammlung.

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

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

Schritt 4: Extrakt Dataset Array

Erstellen Sie eine Reihe von Dataset-Objekten aus den hochgeladenen Dateien.

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

Schritt 5: Serialisieren Sie auf JSON Array

Use DicomJsonSerializer.Serialize mit dem Dataset Array.

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

Schritt 6: Save the JSON Array

Speichern Sie die JSON Array in eine Datei.

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

Vollständiges Code Beispiel

Hier ist ein vollständiges Beispiel, das zeigt, wie man mehrere DICOM-Dateien in eine JSON-Reihe umwandelt:

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

Beispiel JSON Array Output

Die JSON Array-Ausgabe sieht so aus:

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

Datenverarbeitung mit LINQ

Für ein besseres Speichermanagement mit großen Datensätzen verwenden Sie LINQ-Projektionen:

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

Fortschrittsberichten hinzufügen

Für große Spiele fügen Sie Fortschrittsberichte hinzu:

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

Importieren von JSON Array in Analytics Tools

Python Beispiel 

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

Laden Sie in MongoDB 

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

Gedächtnis Beachtung

Bei der Arbeit mit sehr großen Datensätzen:

  • Prozess in Batches: Teilen Sie Dateien in 100-500 Dateien.
  • Stream Output: Verwenden Sie Stream-basierte Serialisierung für sehr große Streams.
  • Dispose Files: Stellen Sie sicher, dass die DicomFile-Objekte nach der Extraktion von Datensätzen gelöscht werden.
// 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);
}

Zusätzliche Informationen

  • Das JSON Array-Format ist ideal für Massenimporten in NoSQL-Datenbanken.
  • Betrachten Sie die Komprimierung großer JSON-Dateien für Speichereffizienz.
  • Für Streaming-Szenarien sollten Sie den NDJSON (newline-delimited JSON) Format verwenden.

Schlussfolgerungen

Dieses Tutorial hat Ihnen gezeigt, wie Sie mehrere DICOM-Dateien in eine einzige JSON-Reihe in C# mit Aspose.Medical konvertieren können.Dieser Ansatz ermöglicht effizienten Massdaten-Export für Analyse, Datenbank-Importe und Datenpipe-Integration.

 Deutsch