Moderne sundhedsapplikationer er stadig mere afhængige af webbaserede grænseflader til at se og administrere medicinsk billeddata. Konvertering af DICOM-filer til JSON muliggør sømløs integration med JavaScript-rammer, REST APIs og cloudplatforme. Denne vejledning viser dig, hvordan du konverterer DIKOM til jSON i C# ved hjælp af Aspose.Medical for .NET.

Hvorfor konvertere DICOM til JSON?

DICOM (Digital Imaging and Communications in Medicine) er det standardformat for medicinsk billed, men dens binære struktur gør det udfordrende at arbejde med i webapplikationer.

  • JavaScript-kompatibilitet: JSON er indfødt i webbrowsere og frontend rammer som React, Vue og Angular
  • REST API integration: JSON er de facto standard for moderne web API’er
  • Databaseopbevaring: NoSQL-databaser som MongoDB opbevarer JSON-dokumenter nativt
  • Menneskelig læsbarhed: JSON er let at inspicere og debugere i forhold til binær DICOM

Den DICOM PS3.18 standard definerer en JSON repræsentation for DIKOM data, der sikrer interoperabilitet gennem sundhedssystemer.

Sæt dit .NET projekt op

Først installerer du Aspose.Medical for .NET og konfigurerer målt licensing:

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æggende DICOM til JSON konvertering

Den nemmeste måde at konvertere en DICOM-fil til 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 til Debugging

Under udviklingen er formateret JSON lettere at læse og debugge:

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

Brug Tag Keywords i stedet for Hex Codes

Som standard bruger DICOM JSON hexadecimal tagcodes. For mere læsbar udgang, brug nøgleordnavne:

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

Opbygning af en REST API Endpoint

Her er, hvordan du opretter en ASP.NET Core endpoint, der konverterer uploadede DICOM-filer til 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-baseret serialisering for store filer

For store DICOM-filer bruger du streamingbaseret serialisering til at reducere hukommelsesbrug:

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 til flere filer

Processer hele kataloger af 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}");
            }
        }
    }
}

Integration med React Frontend

Når din API returnerer JSON, er det nemt at bruge 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>
    );
}

Bedste praksis

Når du konverterer DICOM til JSON til webapplikationer, skal du huske disse tips:

  • Anonymiser før konvertering: Altid fjerne patient-identificerbar information, før du udsender DICOM-data via web-API’er
  • Anvend async-metoder: For webapplikationer skal du bruge assynkron serialisering for at undgå at blokere tråden
  • Cache konverterede data: Hvis de samme DICOM-filer bliver anmodet om ofte, cache JSON-udgang
  • Validering af inputfiler: Kontrollér, at uploadede filer er gyldige DICOM før behandling
  • Handle binære data omhyggeligt: Store pixeldata bør behandles separat eller udelukket fra JSON-responser

Konklusion

Med Aspose.Medical for .NET kan du nemt serialisere DICOM-datasæt til PS3.18-kompatible JSON, opbygge REST APIs og integrere med JavaScript-rammer. Eksempler i denne vejledning giver en grundlag for oprettelse af webbaserede Dicom-visorer, patientportaler og sundhedsdataplatforme.

For mere information om DICOM JSON serialisering muligheder, besøg Medikamenter.Medicinsk dokumentation.

More in this category