Aspose.Medical DICOM til tekstkonverter for .NET Knowledge Base
Hvordan man konverterer flere DICOM filer til en enkelt JSON array

Hvordan man konverterer flere DICOM filer til en enkelt JSON array

Denne tutorial viser, hvordan man konverterer flere DICOM-filer til en enkelt JSON array ved hjælp af C#. Denne tilgang er ideel for data ingeniører, der har brug for at eksportere DIKOM metadata til analytiske værktøjer, databaser eller data pipeliner.

Fordele ved JSON Array Export

  • Bulk Data Processing:- Import flere DICOM-optegnelser til databaser i en enkelt operation.

    • Analytiker er klar til:- JSON-rays kan lastes direkte ind i Python, Spark eller datalagre.
    • Kompakte udstyr *:- En enkelt fil, der indeholder alle metadata, forenkler dataforvaltningen.

Forside: Forberedelse af miljøet

  • Indstill Visual Studio eller ethvert kompatibelt .NET IDE.
  • Skab et nyt .NET 8 applikationsprojekt.
  • Installere Aspose.Medical fra NuGet Package Manager.
  • Forbered en mappe, der indeholder flere DICOM-filer.

Step-by-Step Guide til at konvertere flere DICOM-filer til JSON Array

Trin 1: Installation af Aspose.Medical

Tilføj Aspose.Medicinsk bibliotek til dit projekt ved hjælp af NuGet.

Install-Package Aspose.Medical

Trin 2: Indtast de nødvendige navneområder

Tilføj henvisninger til de krævede navneområder i din kode.

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

Trin 3: Lade flere DICOM-filer

Lad DICOM-filer fra en mappe ind i en samling.

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

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

Trin 4: Udvinding af Dataset Array

Opbygge en række Dataset-objekter fra de ladede filer.

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

Trin 5: Serialiser til JSON Array

Brug af DicomJsonSerializer.Serialize med dataset array.

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

Trin 6: Beskytt JSON Array

Save JSON array til en fil.

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

Fuld kode eksempler

Her er et komplet eksempel, der viser, hvordan man konverterer flere DICOM filer til en JSON rækkefølge:

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

Eksempel på JSON Array Output

Udgang JSON array ser sådan ud:

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

Behandling af store datasæt med LINQ

For bedre hukommelsesstyring med store datasæt, brug LINQ-projektioner:

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

Tilføj fremskridtrapportering

For store kampe, tilføje fremskridtrapportering:

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

Import JSON Array til Analytics værktøjer

Python eksempler 

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

Opladning til MongoDB 

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

Memoriale overvejelser

Når du arbejder med meget store datasæt:

  • Processen i Batches: Opdelt filer i 100-500 filers batches.
  • Stream Output: Brug strømbaseret serialisering til meget store aræer.
  • Dispose Files: Sørg for, at DicomFile-objekter fjernes efter udvinding af datasæt.
// 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);
}

Yderligere information

  • JSON array-format er ideelt til masseimport til NoSQL-databaser.
  • Overvej komprimering af store JSON-filer for lagringseffektivitet.
  • For streaming scenarier, overveje at bruge NDJSON (newline-delimited JSON) format i stedet.

Konklusion

Denne tutorial har vist dig, hvordan man konverterer flere DICOM filer til en enkelt JSON array i C# ved hjælp af Aspose.Medical. Denne tilgang giver mulighed for effektiv massedata eksport for analyse, databaseimport og data pipeline integration.

 Dansk