Mūsdienu veselības aprūpes lietojumprogrammas arvien vairāk paļaujas uz tīklā balstītajām saskarnēm, lai skatītu un pārvaldītu medicīnisko attēlu datus. Konvertējot DICOM failus uz JSON, jūs varat bezjēdzīgi integrēties ar JavaScript sistēmām, REST API un mākoņu platformām. Šis ceļvedis jums rāda, kā konvertēt DIKOM uz C#, izmantojot Aspose.Medical for .NET.

Kāpēc konvertēt DICOM uz JSON?

DICOM (Digital Imaging and Communications in Medicine) ir standarta formāts medicīnas attēlošanai, bet tā binārā struktūra padara to grūti strādāt ar tīmekļa lietojumprogrammām.

  • JavaScript saderība: JSON ir oriģināls tīmekļa pārlūkprogrammām un frontend sistēmām, piemēram, React, Vue un Angular
  • REST API integrācija: JSON ir mūsdienu tīmekļa API de facto standarts
  • Datu bāzes uzglabāšana: NoSQL datubāzes, piemēram, MongoDB, saglabā JSON dokumentus izcils
  • ** Cilvēka lasamība**: JSON ir viegli pārbaudīt un debug salīdzinājumā ar bināro DICOM

DICOM PS3.18 standarts nosaka JSON pārstāvību DIKOM datiem, nodrošinot sadarbspēju starp veselības aprūpes sistēmām.

Izveidojiet savu .NET projektu

Pirmkārt, instalējiet Aspose.Medical .NET un iestatīt mērīto licencēšanu:

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

DICOM uz JSON konversiju

Vienkāršākais veids, kā konvertēt DICOM failu uz 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

Attīstības laikā formatēts JSON ir vieglāk lasīt un izkliedēt:

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

Izmantojiet Tag atslēgvārdus, nevis Hex kodus

Parasti DICOM JSON izmanto hexadecimal etiķetes kodus. Lai iegūtu vairāk lasāmus rezultātus, izmantojiet atslēgvārdu vārdus:

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

Izveidojiet REST API Endpoint

Šeit ir, kā izveidot ASP.NET Core endpoint, kas konvertē lejupielādētos DICOM failus uz 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 serializācija lieliem failiem

Lieliem DICOM failiem, izmantojot streamu bāzes serializāciju, lai samazinātu atmiņas izmantošanu:

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 konversija vairākām failām

Izveidojiet visus DICOM failu 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}");
            }
        }
    }
}

Integrācija ar React Frontend

Kad jūsu API atgriežas JSON, to patērēšana React ir vienkārša:

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

Labākās prakses

Konvertējot DICOM uz JSON tīmekļa lietojumprogrammām, atcerieties šos padomus:

  • Anonimizēt pirms konvertēšanas: vienmēr noņemt pacienta identificējamu informāciju pirms DICOM datu izpaušanas, izmantojot tīmekļa API
  • Izmantojot asinkcijas metodes: tīmekļa lietojumprogrammām, izmantojiet nesinkronu serializāciju, lai izvairītos no blokiem
  • Cache konvertētie dati: Ja tos pašus DICOM failus bieži pieprasa, cache JSON iznākumu
  • Validēt ieejas failus: Pārbaudiet, vai lejupielādētie faili ir DICOM derīgi pirms apstrādes
  • Bināru datu apstrāde rūpīgi: Lieliem piksela datiem vajadzētu apstrādāt atsevišķi vai izslēgt no JSON atbildēm

Conclusion

Konvertējot DICOM failus uz JSON atver medicīnisko attēlu datus mūsdienu tīmekļa attīstībai. Ar Aspose.Medical for .NET, jūs varat viegli serializēt DIKOM datnes uz PS3.18-atbilstošu Json, izveidot REST APIs un integrēt ar JavaScript sistēmām.

Lai iegūtu vairāk informācijas par DICOM JSON serializācijas iespējām, apmeklējiet Aspose.Medicīnas dokumentācija.

More in this category