Las aplicaciones de salud modernas se basan cada vez más en las interfaces basadas en la web para ver y gestionar los datos de imagen médica. Convertir archivos DICOM a JSON permite la integración sin límite con los cadros de JavaScript, las APIs REST y las plataformas de la nube. Esta guía le muestra cómo convertir Dicom a jSON en C# utilizando Aspose.Medical para .NET.

¿Por qué convertir DICOM en JSON?

DICOM (Digital Imaging and Communications in Medicine) es el formato estándar para la imagen médica, pero su estructura binaria lo hace desafiador para trabajar con en aplicaciones web.

  • Compatibilidad de JavaScript: JSON es nativo a los navegadores web y los frameworks frontend como React, Vue y Angular
  • Integración de REST API: JSON es el estándar de facto para las APIs web modernas
  • Base de datos de almacenamiento: NoSQL, como MongoDB, almacena documentos JSON nativos
  • Lecibilidad humana: JSON es fácil de inspeccionar y descargar en comparación con DICOM binario

La norma DICOM PS3.18 define una representación JSON para los datos de Dicom, garantizando la interoperabilidad a través de los sistemas de atención médica.

Desarrollar tu proyecto .NET

En primer lugar, instale Aspose.Medical para .NET y configure la licencia medida:

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

// Activate metered license
Metered metered = new Metered();
metered.SetMeteredKey("your-public-key", "your-private-key");

Conversiones básicas de DICOM a JSON

La forma más sencilla de convertir un archivo DICOM en JSON:

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

public class DicomJsonConverter
{
    public string ConvertToJson(string dicomFilePath)
    {
        // Load the DICOM file
        DicomFile dicomFile = DicomFile.Open(dicomFilePath);
        
        // Serialize dataset to JSON string
        string json = DicomJsonSerializer.Serialize(dicomFile.Dataset);
        
        return json;
    }
}

Pretty-Print JSON para Debugging

Durante el desarrollo, el formato JSON es más fácil de leer y descargar:

public string ConvertToFormattedJson(string dicomFilePath)
{
    DicomFile dicomFile = DicomFile.Open(dicomFilePath);
    
    // Configure serialization options
    var options = new DicomJsonSerializerOptions
    {
        WriteIndented = true  // Enable pretty-print
    };
    
    string json = DicomJsonSerializer.Serialize(dicomFile.Dataset, options);
    
    return json;
}

Usar palabras clave en lugar de hex codes

Por defecto, DICOM JSON utiliza códigos de etiquetas hexadecimal. Para una salida más leible, utilice nombres de palabras clave:

public string ConvertWithKeywords(string dicomFilePath)
{
    DicomFile dicomFile = DicomFile.Open(dicomFilePath);
    
    var options = new DicomJsonSerializerOptions
    {
        WriteIndented = true,
        UseKeywordsAsJsonKeys = true,  // Use "PatientName" instead of "00100010"
        WriteKeyword = true,           // Include keyword in output
        WriteName = true               // Include human-readable name
    };
    
    string json = DicomJsonSerializer.Serialize(dicomFile.Dataset, options);
    
    return json;
}

Construcción de un REST API Endpoint

Aquí está cómo crear un endpoint de ASP.NET Core que converte los archivos DICOM cargados en JSON:

using Microsoft.AspNetCore.Mvc;
using Aspose.Medical.Dicom;
using Aspose.Medical.Dicom.Serialization;

[ApiController]
[Route("api/[controller]")]
public class DicomController : ControllerBase
{
    [HttpPost("to-json")]
    public async Task<IActionResult> ConvertToJson(IFormFile file)
    {
        if (file == null || file.Length == 0)
        {
            return BadRequest("No DICOM file provided");
        }

        try
        {
            // Save uploaded file temporarily
            var tempPath = Path.GetTempFileName();
            using (var stream = new FileStream(tempPath, FileMode.Create))
            {
                await file.CopyToAsync(stream);
            }

            // Convert to JSON
            DicomFile dicomFile = DicomFile.Open(tempPath);
            
            var options = new DicomJsonSerializerOptions
            {
                WriteIndented = true,
                UseKeywordsAsJsonKeys = true
            };
            
            string json = DicomJsonSerializer.Serialize(dicomFile.Dataset, options);

            // Clean up temp file
            System.IO.File.Delete(tempPath);

            return Content(json, "application/json");
        }
        catch (Exception ex)
        {
            return StatusCode(500, $"Conversion failed: {ex.Message}");
        }
    }
    
    [HttpGet("metadata/{fileName}")]
    public IActionResult GetMetadata(string fileName)
    {
        var filePath = Path.Combine("DicomFiles", fileName);
        
        if (!System.IO.File.Exists(filePath))
        {
            return NotFound("DICOM file not found");
        }

        DicomFile dicomFile = DicomFile.Open(filePath);
        
        // Extract specific metadata fields
        var metadata = new
        {
            PatientName = dicomFile.Dataset.GetString(DicomTag.PatientName),
            PatientID = dicomFile.Dataset.GetString(DicomTag.PatientID),
            StudyDate = dicomFile.Dataset.GetString(DicomTag.StudyDate),
            Modality = dicomFile.Dataset.GetString(DicomTag.Modality),
            StudyDescription = dicomFile.Dataset.GetString(DicomTag.StudyDescription)
        };

        return Ok(metadata);
    }
}

Serialización basada en flujo para archivos grandes

Para los archivos DICOM grandes, utilice la serificación basada en el flujo para reducir el uso de la memoria:

public async Task ConvertToJsonStreamAsync(string dicomFilePath, string outputPath)
{
    DicomFile dicomFile = DicomFile.Open(dicomFilePath);
    
    var options = new DicomJsonSerializerOptions
    {
        WriteIndented = true
    };
    
    using (var fileStream = new FileStream(outputPath, FileMode.Create))
    {
        await DicomJsonSerializer.SerializeAsync(
            fileStream, 
            dicomFile.Dataset, 
            options);
    }
}

Conversión de batch para múltiples archivos

Procesar las directorias completas de los archivos DICOM:

public class BatchDicomConverter
{
    public async Task ConvertDirectoryAsync(string inputDir, string outputDir)
    {
        Directory.CreateDirectory(outputDir);
        
        var dicomFiles = Directory.GetFiles(inputDir, "*.dcm");
        
        var options = new DicomJsonSerializerOptions
        {
            WriteIndented = true,
            UseKeywordsAsJsonKeys = true
        };

        foreach (var filePath in dicomFiles)
        {
            try
            {
                DicomFile dicomFile = DicomFile.Open(filePath);
                
                string fileName = Path.GetFileNameWithoutExtension(filePath);
                string outputPath = Path.Combine(outputDir, $"{fileName}.json");
                
                using (var stream = new FileStream(outputPath, FileMode.Create))
                {
                    await DicomJsonSerializer.SerializeAsync(
                        stream, 
                        dicomFile.Dataset, 
                        options);
                }
                
                Console.WriteLine($"Converted: {fileName}");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Failed to convert {filePath}: {ex.Message}");
            }
        }
    }
}

Integración con React Frontend

Una vez que su API vuelve a JSON, consumirlo en React es sencillo:

// React component to display DICOM metadata
import React, { useState } from 'react';

function DicomViewer() {
    const [metadata, setMetadata] = useState(null);
    
    const handleFileUpload = async (event) => {
        const file = event.target.files[0];
        const formData = new FormData();
        formData.append('file', file);
        
        const response = await fetch('/api/dicom/to-json', {
            method: 'POST',
            body: formData
        });
        
        const json = await response.json();
        setMetadata(json);
    };
    
    return (
        <div>
            <input type="file" onChange={handleFileUpload} accept=".dcm" />
            {metadata && (
                <pre>{JSON.stringify(metadata, null, 2)}</pre>
            )}
        </div>
    );
}

Mejores Prácticas

Al convertir DICOM a JSON para aplicaciones web, tenga en cuenta estos consejos:

  • Anonimización antes de la conversión: Remova siempre la información identificable del paciente antes que expone los datos de DICOM a través de APIs web
  • Use métodos de asínculo: Para las aplicaciones web, utilice la serialización sin sincronización para evitar bloquear las filas
  • Cache datos convertidos: Si los mismos archivos DICOM se solicitan con frecuencia, cache la salida JSON
  • Valida los archivos de entrada: Verifique que los ficheros cargados son válidos DICOM antes de procesar
  • Traducir datos binarios con cuidado: Los grandes datos de píxeles deben ser tratados por separado o excluidos de las respuestas de JSON

Conclusión

Convertir archivos DICOM a JSON abre los datos de imagen médica para el desarrollo web moderno. Con Aspose.Medical para .NET, se puede serializar fácilmente los conjuntos de datos DIKOM al J SON compatible con PS3.18, construir APIs REST, e integrarse con los cadros de JavaScript. Los ejemplos en este guía proporcionan una base para la construcción de espectadores web, portales de pacientes y plataformas de información de salud.

Para obtener más información sobre las opciones de serialización de DICOM JSON, visite el Aspose.Documentación médica.

More in this category