Moderne Gesundheitsanwendungen verlassen sich zunehmend auf Web-basierte Schnittstellen für die Anzeige und Verwaltung von medizinischen Bilddaten. Die Konvertierung von DICOM-Dateien in JSON ermöglicht eine unbequeme Integration mit JavaScript-Frameworks, REST APIs und Cloud-Plattformen. Dieser Leitfaden zeigt Ihnen, wie Sie DIKOM in C# mit Aspose.Medical für .NET konvertieren können.

Warum DICOM in JSON umwandeln?

DICOM (Digital Imaging and Communications in Medicine) ist das Standardformat für medizinische Bildung, aber seine binäre Struktur macht es herausfordernd, mit Web-Anwendungen zusammenzuarbeiten.

  • JavaScript-Kompatibilität: JSON ist in Webbrowsern und Frontend-Frameworks wie React, Vue und Angular herkömmlich
  • REST API-Integration: JSON ist der de facto Standard für moderne Web-APIs
  • Database Storage: NoSQL Datenbanken wie MongoDB speichern JSON-Dokumente nativ
  • Männliche Lesbarkeit: JSON ist im Vergleich zu binären DICOM leicht zu überprüfen und abzubauen

Das DICOM PS3.18-Standard definiert eine JSON-Repräsentation für DIKOM-Daten, die die Interoperabilität über Gesundheitssysteme gewährleistet.

Installieren Sie Ihr .NET-Projekt

Zuerst installieren Sie Aspose.Medical für .NET und konfigurieren Sie die gemessene Lizenzierung:

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

Basic DICOM zu JSON Conversion

Der einfachste Weg, um eine DICOM-Datei in JSON zu konvertieren:

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 für Debugging

Während der Entwicklung ist formatierte JSON leichter zu lesen und zu debugieren:

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

Tag Keywords anstelle von Hex Codes verwenden

Standardmäßig verwendet DICOM JSON hexadecimal Tag-Codes. Für mehr Lesbarer Ausgang verwenden Sie Keyword-Namen:

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

Aufbau eines REST API Endpoint

Hier ist, wie Sie eine ASP.NET Core Endpoint erstellen, die hochgeladenen DICOM-Dateien in JSON umwandelt:

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

Stream-basierte Serialisierung für große Dateien

Für große DICOM-Dateien verwenden Sie Stream-basierte Serialisierung, um den Speicherverbrauch zu reduzieren:

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

Batch-Konvertierung für mehrere Dateien

Verarbeiten Sie die gesamten Kataloge von DICOM-Dateien:

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

Integration mit React Frontend

Sobald Ihre API JSON zurückkehrt, ist die Verwendung in React einfach:

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

Beste Praktiken

Wenn Sie DICOM in JSON für Web-Anwendungen konvertieren, halten Sie diese Tipps im Auge:

  • Anonymisieren Sie sich vor der Konvertierung: Entfernen Sie immer die identifizierbaren Patienteninformationen, bevor Sie DICOM-Daten über Web APIs exponieren
  • Verwendung von Async-Methoden: Für Web-Anwendungen verwenden Sie asynchronous-Serialisierung, um die Blockierung von Strängen zu vermeiden
  • Cache konvertierte Daten: Wenn die gleichen DICOM-Dateien häufig angefordert werden, cache die JSON-Ausgabe
  • Validieren Sie Eingabedateien: Überprüfen Sie, ob die hochgeladenen Dateien vor der Verarbeitung DICOM gültig sind
  • Binare Daten sorgfältig handeln: Große Pixel-Daten sollten getrennt oder aus JSON-Reaktionen ausgeschlossen werden

Schlussfolgerungen

Die Konvertierung von DICOM-Dateien in JSON öffnet medizinische Bilddaten für die moderne Webentwicklung. Mit Aspose.Medical für .NET können Sie leicht serialisieren DIKOM Datensätze zu PS3.18-komplizierter JSon, erstellen REST APIs und integrieren mit JavaScript-Frameworks. Die Beispiele in diesem Leitfaden bieten eine Grundlage für den Aufbau von Web-basierten DIM-Zuschauern, Patienten-Portale und Gesundheitsinformationsplattformen.

Weitere Informationen über die DICOM JSON-Serialisierungsoptionen finden Sie im Aspose.Medizinische Dokumentation.

More in this category