Šiuolaikinės sveikatos priežiūros programos vis dažniau remiasi žiniatinklio sąsajais peržiūrėti ir valdyti medicinos vaizdo duomenis. Konvertuojant DICOM failus į JSON leidžiama nesąmoningai integruotis su JavaScript rėmenimis, REST API ir debesų platformomis. Šis vadovas rodo, kaip konvertuoti DIKOM į C# naudojant Aspose.Medical .NET.

Kodėl verta konvertuoti DICOM į JSON?

DICOM (Digital Imaging and Communications in Medicine) yra standartinis formatas medicinos vaizdavimui, tačiau jo dvejetainė struktūra daro tai sudėtinga dirbti su žiniatinklio programomis.

  • JavaScript suderinamumas: JSON yra kilmingas žiniatinklio naršyklėms ir frontend sistemoms, tokioms kaip React, Vue ir Angular
  • REST API integracija: JSON yra de facto standartas šiuolaikiniams interneto API
  • Duomenų bazės saugojimas: NoSQL duomenų bazių, pavyzdžiui, MongoDB saugoti JSON dokumentus natūraliai
  • Žmogaus skaitomumas: JSON lengva patikrinti ir iškrauti, palyginti su binariniu DICOM

DICOM PS3.18 standartai apibrėžia JSON atvaizdą, kuriuo užtikrinamas sąveikumas tarp sveikatos priežiūros sistemų.

Įdiegti savo .NET projektą

Pirmiausia įdiegti Aspose.Medical .NET ir konfigūruoti matuotą licenciją:

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

Pagrindinis DICOM į JSON konvertavimas

Paprasčiausias būdas konvertuoti DICOM failą į 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 Debugging

Plėtojimo metu formatuotas JSON lengviau skaityti ir iškrauti:

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

Naudokite žymėjimo raktinius žodžius vietoj Hex kodų

Pavyzdžiui, DICOM JSON naudoja hexadecimal tag kodus. norint skaityti daugiau, naudokite raktinių žodžių vardus:

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

Atnaujinkite „REST API Endpoint“

Štai kaip sukurti ASP.NET Core galutinį tašką, kuris konvertuoja įkelti DICOM failus į 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-based serializavimas dideliems failams

Dideliems DICOM failams naudokite srauto pagrįstą serializavimą, kad sumažintumėte atminties naudojimą:

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 konvertavimas daugybei failų

Apdoroti visus DICOM failų katalogus:

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

Integruotis su „React Frontend“

Kai jūsų API grįžta į JSON, vartojant jį React yra paprasta:

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

Geriausios praktikos

Konvertuojant DICOM į JSON žiniatinklio programoms, atminkite šiuos patarimus:

  • Anonimizuoti prieš konvertavimą: Visada pašalinti paciento identifikuojamą informaciją prieš atskleidžiant DICOM duomenis per interneto API
  • Naudokite asynchrono metodus: interneto programoms naudokite asimetrinę serializavimą, kad išvengtumėte blokuojančių juostų
  • Cache konvertuoti duomenys: Jei tuos pačius DICOM failus paprašoma dažnai, Cache JSON ištrauką
  • Validuokite įvesties failus: prieš apdorojimą patikrinkite, ar įkelti failai yra galiojantys DICOM
  • Binariniai duomenys tvarkomi atsargiai: dideli pikselių duomenis reikia tvarkyti atskirai arba pašalinti iš JSON atsakymų

Conclusion

Konvertavimas DICOM failus į JSON atveria medicinos vaizdavimo duomenis šiuolaikiniam žiniatinklio plėtrai. su Aspose.Medical .NET, galite lengvai serijuoti DIKOM duomenų rinkinius į PS3.18 atitinkamą „JSON“, kurti REST APIs ir integruoti su JavaScript rėmeliais. Šioje vadovoje pateikiami pavyzdžiai suteikia pagrindą sukurti tinklalapyje pagrįstus DIDOM žiūrovus, pacientų portalus ir sveikatos priežiūros duomenų platformas.

Norėdami gauti daugiau informacijos apie DICOM JSON serializavimo galimybes, apsilankykite Aspose.Medicininė dokumentacija.

More in this category