Aspose.Medical DICOM în Text Converter pentru baza de cunoștințe .NET
Cum să convertiți mai multe fișiere DICOM într-o singură arie JSON

Cum să convertiți mai multe fișiere DICOM într-o singură arie JSON

Acest tutorial demonstrează modul de a converti mai multe fișiere DICOM într-o singură rețea JSON folosind C#. Această abordare este ideală pentru inginerii de date care au nevoie să exporte metadate DIKOM pentru instrumente de analiză, baze de informații sau pipeline.

Beneficiile JSON Array Export

    • Procesarea datelor cu caracter personal**:- Importul mai multor înregistrări DICOM în baze de date într-o singură operațiune.

  • • Analiză pregătită:- Array-urile JSON pot fi încărcate direct în stocurile Python, Spark sau de date.

    • Expoziție compactă *:- Un singur fișier care conține toate metadatele simplifică gestionarea datelor.

Etichetă: pregătirea mediului

  • Instalați Visual Studio sau orice IDE compatibil .NET.
  • Creați un nou proiect de aplicații .NET 8 console.
  • Instalați Aspose.Medical de la NuGet Package Manager.
  • Pregătiți un folder care conține mai multe fișiere DICOM.

Ghid pas cu pas pentru a converti mai multe fișiere DICOM în JSON Array

Pasul 1: Instalați Aspose.Medical

Adăugați biblioteca Aspose.Medical la proiectul dvs. folosind NuGet.

Install-Package Aspose.Medical

Pasul 2: Includeți spațiile de nume necesare

Adăugați referințe la spațiile de nume necesare în codul dvs.

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

Pasul 3: Încărcați mai multe fișiere DICOM

Încărcați fișierele DICOM dintr-un folder într-o colecție.

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

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

Pasul 4: Extract Dataset Array

Creați o serie de obiecte Dataset din fișierele încărcate.

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

Pasul 5: Serializarea la JSON Array

Utilizarea DicomJsonSerializer.Serialize cu arrayul Dataset.

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

Pasul 6: Salvați JSON Array

Salvați aria JSON într-un fișier.

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

Exemplu complet de cod

Iată un exemplu complet care demonstrează modul de a converti mai multe fișiere DICOM într-o arie 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}");

Exemplul JSON Array Output

Produsul JSON array arată așa:

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

Procesarea seturilor de date mari cu LINQ

Pentru o mai bună gestionare a memoriei cu seturi mari de date, utilizați proiecțiile 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.");

Adăugarea rapoartelor de progres

Pentru batch-uri mari, adăugați raportarea progresului:

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

Importarea JSON Array în instrumente de analiză

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

Încărcare în MongoDB 

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

Gândirea memoriei

Când lucrați cu seturi de date foarte mari:

  • Proces în batch-uri: împărțiți fișierele în seturi de 100-500 fișiere.
  • Stream Output: Utilizați serializarea bazată pe flux pentru raze foarte mari.
  • Dispose Files: Asigurați-vă că obiectele DicomFile sunt eliminate după extragerea seturilor de date.
// 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);
}

Informații suplimentare

  • Formatul JSON array este ideal pentru importurile în numerar în bazele de date NoSQL.
  • Gândiți-vă la compresarea fișierelor JSON mari pentru eficiența stocării.
  • Pentru scenarii de streaming, luați în considerare utilizarea formatului NDJSON (newline-delimited JSON) în schimb.

concluziile

Acest tutorial v-a arătat cum să convertiți mai multe fișiere DICOM într-o singură linie JSON în C# folosind Aspose.Medical. Această abordare permite o exportare eficientă a datelor cu amploare pentru analiză, importuri de baze de date și integrare a pipelinei datelor.

 Română