Aspose.Medical DICOM à Converteur de texte pour la base de connaissances .NET
Comment convertir plusieurs fichiers DICOM en un array JSON unique

Comment convertir plusieurs fichiers DICOM en un array JSON unique

Ce tutoriel démontre comment convertir plusieurs fichiers DICOM en une seule array JSON en utilisant C#. Cette approche est idéale pour les ingénieurs de données qui ont besoin d’exporter les métadonnées DIKOM pour des outils d’analyse, des bases de dati, ou des pipelines de data.

Les avantages de JSON Array Export

  • ** Traitement des données de bulk** :- Importer plusieurs enregistrements DICOM dans des bases de données dans une seule opération.

  • Les analystes sont prêts :- Les rayons JSON peuvent être chargés directement dans Python, Spark ou les stockages de données.

    • Output compact * :- Un fichier unique contenant tous les métadonnées simplifie la gestion des données.

Étiquette : Préparer l’environnement

  • Configurez Visual Studio ou tout IDE .NET compatible.
  • Créer un nouveau projet d’application pour la console .NET 8.
  • Installez Aspose.Medical à partir du NuGet Package Manager.
  • Préparez un dossier contenant plusieurs fichiers DICOM.

Guide pas à pas pour convertir plusieurs fichiers DICOM en JSON Array

Étape 1 : Installer Aspose.Medical

Ajoutez la bibliothèque Aspose.Medical à votre projet en utilisant NuGet.

Install-Package Aspose.Medical

Étape 2 : Inclure les espaces de nom nécessaires

Ajoutez des références aux espaces de nom requis dans votre code.

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

Étape 3 : Télécharger plusieurs fichiers DICOM

Téléchargez les fichiers DICOM d’un dossier dans une collection.

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

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

Étape 4 : Extrait de Dataset Array

Créer une gamme d’objets Dataset des fichiers chargés.

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

Étape 5 : Sérialiser avec JSON Array

Utiliser DicomJsonSerializer.Serialize avec le Dataset Array.

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

Étape 6 : Sauvez le JSON Array

Sauvez l’array JSON dans un fichier.

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

Exemple de code complet

Voici un exemple complet démontrant comment convertir plusieurs fichiers DICOM à une série 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 JSON Array Output

La sortie JSON array ressemble à ceci:

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

Traitement de grandes données avec LINQ

Pour une meilleure gestion de la mémoire avec de grands ensembles de données, utilisez les projections 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.");

Ajouter des rapports de progrès

Pour les grands matchs, ajoutez le rapport 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.");

Importer JSON Array dans les outils d’analyse

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

Télécharger sur MongoDB 

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

Considérations de mémoire

Lorsque vous travaillez avec des données très grandes :

  • Procédé dans les pièces: Diviser les fichiers en 100-500 fiches.
  • Stream Output: Utilisez la sérialisation basée sur le flux pour des rayons très grands.
  • Dispose Fichiers: Assurez-vous que les objets DicomFile sont éliminés après l’extraction de données.
// 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);
}

Informations supplémentaires

  • Le format JSON est idéal pour les importations en masse dans les bases de données NoSQL.
  • Considérer la compression de grands fichiers JSON pour l’efficacité de stockage.
  • Pour les scénarios de streaming, pensez à utiliser le format NDJSON (newline-delimited JSON) au lieu.

Conclusion

Ce tutoriel vous a montré comment convertir plusieurs fichiers DICOM dans un ensemble unique JSON en C# en utilisant Aspose.Medical. Cette approche permet d’exporter des données en masse efficaces pour les analyses, les importations de bases de données et l’intégration du pipeline de data.

 Français