Moderna hälso- och sjukvårdsapplikationer förlitar sig alltmer på webbaserade gränssnitt för att se och hantera medicinska bilddata. Konverteringen av DICOM-filer till JSON möjliggör oavbruten integration med JavaScript-ramar, REST APIs och molnplattformar. Denna guide visar dig hur man konverterar DIKOM till C# med hjälp av Aspose.Medical för .NET.

Varför konvertera DICOM till JSON?

DICOM (Digital Imaging and Communications in Medicine) är det standardformat för medicinsk bild, men dess binära struktur gör det utmanande att arbeta med i webbapplikationer.

  • JavaScript-kompatibilitet: JSON är ursprungliga till webbläsare och frontendram som React, Vue och Angular
  • REST API integration: JSON är de facto standard för moderna webbAPI
  • Databaslagring: NoSQL-databaser som MongoDB lagrar JSON-dokument nativt
  • Human läsbarhet: JSON är lätt att inspektera och debug jämfört med binär DICOM

Den DICOM PS3.18 standard definierar en JSON-representation för DIKOM-data, vilket säkerställer interoperabilitet över hälso- och sjukvårdssystem.

Ställ upp ditt .NET-projekt

Först installera Aspose.Medical för .NET och konfigurera måttlig licens:

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

Grundläggande DICOM till JSON konvertering

Det enklaste sättet att konvertera en DICOM-fil till 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 för debugging

Under utvecklingen är formatad JSON lättare att läsa och debugga:

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

Använd tag-nyckelord i stället för hexkoder

Som standard använder DICOM JSON hexadecimal tagkoder. För mer läsbar utgång, använd nyckelordnamn:

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

Att bygga en REST API Endpoint

Här är hur man skapar en ASP.NET Core endpoint som konverterar nedladdade DICOM-filer till 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);
    }
}

Stream-baserad serialisering för stora filer

För stora DICOM-filer, använd strömbaserad serialisering för att minska minnesanvändningen:

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 konvertering för flera filer

Processera hela kataloger av DICOM-filer:

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

Integrera med React Frontend

När din API returnerar JSON är det enkelt att konsumera den i React:

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

Bästa praxis

När du konverterar DICOM till JSON för webbapplikationer, håll dessa tips i åtanke:

  • Anonymiserad före konvertering: Aldrig ta bort patienten identifierbar information innan du exponerar DICOM-data via webbAPI
  • Använda async-metoder: För webbapplikationer, använd assynkron serialisering för att undvika att blockera trådar
  • Cache konverterade data: Om samma DICOM-filer begärs ofta, cache JSON-utgången
  • Validerar inmatningsfiler: Kontrollera att uppladdade filer är giltiga DICOM före bearbetning
  • Handla binära data noggrant: Stora pixeldata ska hanteras separat eller uteslutas från JSON-reaktioner

slutsatser

Konverteringen av DICOM-filer till JSON öppnar medicinska bilddata för modern webbutveckling. Med Aspose.Medical för .NET kan du enkelt serialisera datasets till PS3.18-kompatibla JSon, bygga REST APIs och integrera med JavaScript-ramar. Exempel i denna guide ger en grund för att byggt webbaserade DIKOM tittare, patientportaler och hälso- och sjukvårdsdataplattform.

För mer information om DICOM JSON serialiseringsalternativ, besök Aspose.Medicinsk dokumentation.

More in this category