Aplicațiile moderne de sănătate se bazează din ce în ce mai mult pe interfețele web pentru vizualizarea și gestionarea datelor imaginii medicale. Convertirea fișierelor DICOM la JSON permite integrarea fără întârziere cu cadrele JavaScript, API-urile REST și platformele cloud. Acest ghid vă arată cum să convertiți DIKOM în C# folosind Aspose.Medical pentru .NET.

De ce să transformi DICOM în JSON?

DICOM (Digital Imaging and Communications in Medicine) este formatul standard pentru imaginea medicală, dar structura sa binară îl face dificil să lucreze cu aplicațiile web.

  • Compatibilitatea JavaScript: JSON este nativă browserelor web și cadrelor frontend, cum ar fi React, Vue și Angular
  • Integrația REST API: JSON este standardul de facto pentru API-urile web moderne
  • Baza de stocare a datelor: NoSQL baze de date cum ar fi MongoDB stocarea documentelor JSON în mod nativ
  • Lecabilitate umană: JSON este ușor de inspectat și debarcat în comparație cu DICOM binar

Standardul DICOM PS3.18 definește o reprezentare JSON pentru datele DIKOM, asigurând interoperabilitatea între sistemele de asistență medicală.

Instalarea proiectului .NET

În primul rând, instalați Aspose.Medical pentru .NET și configurați licența măsurată:

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

Conversie de bază la JSON

Cea mai simplă modalitate de a converti un fișier DICOM în 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 pentru debugging

În timpul dezvoltării, JSON format este mai ușor de citit și de debug:

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

Utilizarea cuvintelor cheie în loc de coduri hex

De preferință, DICOM JSON utilizează coduri de etichetă hexadecimală. Pentru o producție mai citabilă, utilizați numele cuvintelor cheie:

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

Construirea unui REST API Endpoint

Iată cum să creați un endpoint ASP.NET Core care convertează fișierele DICOM încărcate în 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);
    }
}

Serializare bazată pe flux pentru fișierele mari

Pentru fișierele DICOM mari, utilizați serializarea bazată pe flux pentru a reduce utilizarea memoriei:

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

Conversie batch pentru mai multe fișiere

Procesarea directorilor complete ale fișierelor 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}");
            }
        }
    }
}

Integrarea cu React Frontend

Odată ce API-ul dvs. se întoarce la JSON, consumarea acestuia în React este simplă:

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

Cele mai bune practici

Când convertiți DICOM la JSON pentru aplicații web, țineți cont de aceste sfaturi:

  • Anonimizați înainte de conversie: Eliminați întotdeauna informațiile identificabile pacienților înainte să expuneți datele DICOM prin intermediul API-urilor web
  • Metode async: Pentru aplicații web, utilizați serializarea asincronă pentru a evita blocarea lanțurilor
  • Cache data convertită: Dacă aceleași fișiere DICOM sunt solicitate frecvent, cache-ul de ieșire JSON
  • Validați fișierele de intrare: Verificați că fișiere încărcate sunt valabile DICOM înainte de prelucrare
  • Tratează cu atenție datele binare: Datele cu pixel mari trebuie tratate separat sau excluse din răspunsurile JSON

concluziile

Conversia fișierelor DICOM la JSON deschide date de imagini medicale pentru dezvoltarea modernă a web-ului. Cu Aspose.Medical pentru .NET, puteți serialize cu ușurință seturile de date Dicom la PS3.18-compliant JSon, construiți APIs REST și integrați cu cadrele JavaScript. Exemplele din acest ghid oferă o bază pentru construirea vizionarilor web DIKOM, portaluri pentru pacienți și platforme de informații privind sănătatea.

Pentru mai multe informații despre opțiunile de serializare DICOM JSON, vizitați Aspose.Documentație medicală.

More in this category