Aspose.Medical DICOM para Text Converter para .NET Knowledge Base
Como converter vários arquivos DICOM em um único array JSON

Como converter vários arquivos DICOM em um único array JSON

Este tutorial demonstra como converter múltiplos arquivos DICOM em um único array JSON usando C#. Esta abordagem é ideal para engenheiros de dados que precisam exportar metadados DIKOM para ferramentas de análise, bancos de informações ou tubos de informação.

Benefícios do JSON Array Export

  • ** Processamento de dados do Bulk**:- Importar vários registros DICOM em bases de dados em uma única operação.

    • Análise está pronta:- Os arquivos JSON podem ser carregados diretamente para Python, Spark ou armazéns de dados.
    • Output compacto *:- Um único arquivo que contém todos os metadados simplifica a gestão de dados.

Título: Preparando o Meio Ambiente

  • Instale o Visual Studio ou qualquer .NET IDE compatível.
  • Crie um novo projeto de aplicação .NET 8 console.
  • Instale Aspose.Medical do NuGet Package Manager.
  • Prepare uma pasta que contenha vários arquivos DICOM.

Guia passo a passo para converter múltiplos arquivos DICOM para JSON Array

Passo 1: Instalar Aspose.Medical

Adicione a Aspose.Medical Library ao seu projeto usando NuGet.

Install-Package Aspose.Medical

Passo 2: Incluir os espaços de nome necessários

Adicione referências aos espaços de nomes necessários em seu código.

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

Passo 3: Carregar múltiplos arquivos DICOM

Carregar arquivos DICOM de uma pasta em uma coleção.

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

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

Passo 4: Extração de Dataset Array

Crie uma série de objetos do Dataset dos arquivos carregados.

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

Passo 5: Serialize para JSON Array

Utilização DicomJsonSerializer.Serialize com o Dataset Array.

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

Passo 6: Salve o JSON Array

Salve o array JSON para um arquivo.

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

Exemplo de código completo

Aqui está um exemplo completo mostrando como converter múltiplos arquivos DICOM em um array 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}");

Exemplo de JSON Array Output

A saída do JSON array parece assim:

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

Processamento de Big Data com o LINQ

Para melhor gestão da memória com grandes conjuntos de dados, use projeções 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.");

Adicionar relatórios de progresso

Para grandes partidas, adicione o relatório de progresso:

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

Importar JSON Array para Ferramentas de Análise

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

Carregar em MongoDB 

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

Considerações de memória

Ao trabalhar com grandes conjuntos de dados:

  • Processo em Batches: Divida os arquivos em batches de 100-500 ficheiros.
  • Stream Output: Use serialização baseada no fluxo para arredores muito grandes.
  • Dispose Files: Assegure-se de que os objetos do DicomFile são eliminados após a extração de conjuntos de dados.
// 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ções adicionais

  • O formato de array JSON é ideal para importações em massa em bases de dados NoSQL.
  • Considere a compressão de grandes arquivos JSON para eficiência de armazenamento.
  • Para cenários de streaming, considere usar o formato NDJSON (newline-delimited JSON) em vez disso.

Conclusão

Este tutorial mostrou-lhe como converter vários arquivos DICOM em um único array JSON em C# usando Aspose.Medical. Esta abordagem permite uma exportação eficiente de dados em massa para análises, importações de banco de datos e integração de tubos de data.

 Português