Comprendere il contenuto del file DICOM è essenziale per lo sviluppo dell’immagine medica, la risoluzione dei problemi e l’assicurazione della qualità.Questo tutorial ti mostra come costruire un visualizzatore completo dei metadati DIKOM in C# che estrae e mostra le informazioni del paziente, i dettagli dello studio e i parametri di immagine tecnica.

Cosa sono i metadati di DICOM?

I file DICOM contengono due componenti principali: i dati pixel (l’immagine reale) e i metadati (informazione sulla immagine).

  • ** Demografia del paziente**: nome, ID, data di nascita, sesso
  • Informazioni di studio: data, ora, descrizione, medico di riferimento
  • ** Dettagli di serie**: Modalità, parte del corpo, protocollo di immagine
  • ** Parametri di immagine**: Dimensioni, spazio pixel, impostazioni di finestra/livello
  • Informazioni di attrezzature: produttore, modello, versione software

Un visualizzatore dei metadati aiuta gli sviluppatori a controllare questi attributi per il debugging, la validazione e l’analisi dei dati.

L’estrazione dei metadati

Inizia con l’estrazione di attributi comuni DICOM:

using Aspose.Medical.Dicom;

public class DicomMetadataViewer
{
    public DicomMetadata ExtractMetadata(string filePath)
    {
        DicomFile dicomFile = DicomFile.Open(filePath);
        var dataset = dicomFile.Dataset;
        
        return new DicomMetadata
        {
            // Patient Information
            PatientName = dataset.GetString(DicomTag.PatientName),
            PatientID = dataset.GetString(DicomTag.PatientID),
            PatientBirthDate = dataset.GetString(DicomTag.PatientBirthDate),
            PatientSex = dataset.GetString(DicomTag.PatientSex),
            PatientAge = dataset.GetString(DicomTag.PatientAge),
            
            // Study Information
            StudyInstanceUID = dataset.GetString(DicomTag.StudyInstanceUID),
            StudyDate = dataset.GetString(DicomTag.StudyDate),
            StudyTime = dataset.GetString(DicomTag.StudyTime),
            StudyDescription = dataset.GetString(DicomTag.StudyDescription),
            AccessionNumber = dataset.GetString(DicomTag.AccessionNumber),
            ReferringPhysician = dataset.GetString(DicomTag.ReferringPhysicianName),
            
            // Series Information
            SeriesInstanceUID = dataset.GetString(DicomTag.SeriesInstanceUID),
            Modality = dataset.GetString(DicomTag.Modality),
            SeriesDescription = dataset.GetString(DicomTag.SeriesDescription),
            SeriesNumber = dataset.GetString(DicomTag.SeriesNumber),
            BodyPartExamined = dataset.GetString(DicomTag.BodyPartExamined),
            
            // Image Information
            SOPInstanceUID = dataset.GetString(DicomTag.SOPInstanceUID),
            SOPClassUID = dataset.GetString(DicomTag.SOPClassUID),
            InstanceNumber = dataset.GetString(DicomTag.InstanceNumber),
            ImageType = dataset.GetString(DicomTag.ImageType),
            
            // Technical Parameters
            Rows = dataset.GetString(DicomTag.Rows),
            Columns = dataset.GetString(DicomTag.Columns),
            BitsAllocated = dataset.GetString(DicomTag.BitsAllocated),
            BitsStored = dataset.GetString(DicomTag.BitsStored),
            PixelSpacing = dataset.GetString(DicomTag.PixelSpacing),
            SliceThickness = dataset.GetString(DicomTag.SliceThickness),
            
            // Equipment Information
            Manufacturer = dataset.GetString(DicomTag.Manufacturer),
            ManufacturerModelName = dataset.GetString(DicomTag.ManufacturerModelName),
            StationName = dataset.GetString(DicomTag.StationName),
            InstitutionName = dataset.GetString(DicomTag.InstitutionName),
            SoftwareVersions = dataset.GetString(DicomTag.SoftwareVersions)
        };
    }
}

public class DicomMetadata
{
    // Patient
    public string PatientName { get; set; }
    public string PatientID { get; set; }
    public string PatientBirthDate { get; set; }
    public string PatientSex { get; set; }
    public string PatientAge { get; set; }
    
    // Study
    public string StudyInstanceUID { get; set; }
    public string StudyDate { get; set; }
    public string StudyTime { get; set; }
    public string StudyDescription { get; set; }
    public string AccessionNumber { get; set; }
    public string ReferringPhysician { get; set; }
    
    // Series
    public string SeriesInstanceUID { get; set; }
    public string Modality { get; set; }
    public string SeriesDescription { get; set; }
    public string SeriesNumber { get; set; }
    public string BodyPartExamined { get; set; }
    
    // Image
    public string SOPInstanceUID { get; set; }
    public string SOPClassUID { get; set; }
    public string InstanceNumber { get; set; }
    public string ImageType { get; set; }
    
    // Technical
    public string Rows { get; set; }
    public string Columns { get; set; }
    public string BitsAllocated { get; set; }
    public string BitsStored { get; set; }
    public string PixelSpacing { get; set; }
    public string SliceThickness { get; set; }
    
    // Equipment
    public string Manufacturer { get; set; }
    public string ManufacturerModelName { get; set; }
    public string StationName { get; set; }
    public string InstitutionName { get; set; }
    public string SoftwareVersions { get; set; }
}

Visualizza tutti i tag DICOM

Inserisci tutte le etichette in un file DICOM per l’esame completo:

public class DicomTagBrowser
{
    public List<DicomTagInfo> GetAllTags(string filePath)
    {
        DicomFile dicomFile = DicomFile.Open(filePath);
        var tags = new List<DicomTagInfo>();
        
        foreach (var element in dicomFile.Dataset)
        {
            var tagInfo = new DicomTagInfo
            {
                Tag = element.Tag.ToString(),
                TagHex = $"({element.Tag.Group:X4},{element.Tag.Element:X4})",
                Keyword = element.Tag.DictionaryEntry?.Keyword ?? "Unknown",
                Name = element.Tag.DictionaryEntry?.Name ?? "Private Tag",
                VR = element.ValueRepresentation.Code,
                Length = element.Length,
                Value = GetDisplayValue(element)
            };
            
            tags.Add(tagInfo);
        }
        
        return tags;
    }

    private string GetDisplayValue(DicomElement element)
    {
        try
        {
            // Handle different value representations
            if (element.Length == 0)
                return "(empty)";
            
            if (element.Length > 256)
                return $"(binary data, {element.Length} bytes)";
            
            // Try to get string value
            var values = element.Get<string[]>();
            if (values != null && values.Length > 0)
            {
                return string.Join(" \\ ", values);
            }
            
            return "(unable to display)";
        }
        catch
        {
            return $"(binary data, {element.Length} bytes)";
        }
    }
}

public class DicomTagInfo
{
    public string Tag { get; set; }
    public string TagHex { get; set; }
    public string Keyword { get; set; }
    public string Name { get; set; }
    public string VR { get; set; }
    public long Length { get; set; }
    public string Value { get; set; }
}

L’estrazione di metadati specifici

Diverse modalità di immagine hanno attributi unici:

public class ModalityMetadataExtractor
{
    public object ExtractModalitySpecificData(string filePath)
    {
        DicomFile dicomFile = DicomFile.Open(filePath);
        var dataset = dicomFile.Dataset;
        
        string modality = dataset.GetString(DicomTag.Modality);
        
        return modality switch
        {
            "CT" => ExtractCtMetadata(dataset),
            "MR" => ExtractMrMetadata(dataset),
            "CR" or "DX" => ExtractRadiographyMetadata(dataset),
            "US" => ExtractUltrasoundMetadata(dataset),
            "MG" => ExtractMammographyMetadata(dataset),
            _ => ExtractGenericMetadata(dataset)
        };
    }

    private CtMetadata ExtractCtMetadata(DicomDataset dataset)
    {
        return new CtMetadata
        {
            KVP = dataset.GetString(DicomTag.KVP),
            XRayTubeCurrent = dataset.GetString(DicomTag.XRayTubeCurrent),
            ExposureTime = dataset.GetString(DicomTag.ExposureTime),
            SliceThickness = dataset.GetString(DicomTag.SliceThickness),
            SpacingBetweenSlices = dataset.GetString(DicomTag.SpacingBetweenSlices),
            ConvolutionKernel = dataset.GetString(DicomTag.ConvolutionKernel),
            GantryTilt = dataset.GetString(DicomTag.GantryDetectorTilt),
            TableHeight = dataset.GetString(DicomTag.TableHeight),
            RotationDirection = dataset.GetString(DicomTag.RotationDirection),
            CTDIvol = dataset.GetString(DicomTag.CTDIvol),
            WindowCenter = dataset.GetString(DicomTag.WindowCenter),
            WindowWidth = dataset.GetString(DicomTag.WindowWidth)
        };
    }

    private MrMetadata ExtractMrMetadata(DicomDataset dataset)
    {
        return new MrMetadata
        {
            MagneticFieldStrength = dataset.GetString(DicomTag.MagneticFieldStrength),
            SequenceName = dataset.GetString(DicomTag.SequenceName),
            ScanningSequence = dataset.GetString(DicomTag.ScanningSequence),
            SequenceVariant = dataset.GetString(DicomTag.SequenceVariant),
            RepetitionTime = dataset.GetString(DicomTag.RepetitionTime),
            EchoTime = dataset.GetString(DicomTag.EchoTime),
            InversionTime = dataset.GetString(DicomTag.InversionTime),
            FlipAngle = dataset.GetString(DicomTag.FlipAngle),
            SliceThickness = dataset.GetString(DicomTag.SliceThickness),
            EchoTrainLength = dataset.GetString(DicomTag.EchoTrainLength),
            PixelBandwidth = dataset.GetString(DicomTag.PixelBandwidth),
            ImagingFrequency = dataset.GetString(DicomTag.ImagingFrequency)
        };
    }

    private RadiographyMetadata ExtractRadiographyMetadata(DicomDataset dataset)
    {
        return new RadiographyMetadata
        {
            KVP = dataset.GetString(DicomTag.KVP),
            ExposureTime = dataset.GetString(DicomTag.ExposureTime),
            XRayTubeCurrent = dataset.GetString(DicomTag.XRayTubeCurrent),
            Exposure = dataset.GetString(DicomTag.Exposure),
            ExposureIndex = dataset.GetString(DicomTag.ExposureIndex),
            TargetExposureIndex = dataset.GetString(DicomTag.TargetExposureIndex),
            DeviationIndex = dataset.GetString(DicomTag.DeviationIndex),
            DistanceSourceToDetector = dataset.GetString(DicomTag.DistanceSourceToDetector),
            DistanceSourceToPatient = dataset.GetString(DicomTag.DistanceSourceToPatient),
            Grid = dataset.GetString(DicomTag.Grid),
            ViewPosition = dataset.GetString(DicomTag.ViewPosition)
        };
    }

    private UltrasoundMetadata ExtractUltrasoundMetadata(DicomDataset dataset)
    {
        return new UltrasoundMetadata
        {
            TransducerType = dataset.GetString(DicomTag.TransducerType),
            TransducerFrequency = dataset.GetString(DicomTag.TransducerFrequency),
            DepthOfScanField = dataset.GetString(DicomTag.DepthOfScanField),
            MechanicalIndex = dataset.GetString(DicomTag.MechanicalIndex),
            ThermalIndex = dataset.GetString(DicomTag.SoftTissueThermalIndex),
            FrameTime = dataset.GetString(DicomTag.FrameTime),
            NumberOfFrames = dataset.GetString(DicomTag.NumberOfFrames)
        };
    }

    private MammographyMetadata ExtractMammographyMetadata(DicomDataset dataset)
    {
        return new MammographyMetadata
        {
            ViewPosition = dataset.GetString(DicomTag.ViewPosition),
            ImageLaterality = dataset.GetString(DicomTag.ImageLaterality),
            BreastImplantPresent = dataset.GetString(DicomTag.BreastImplantPresent),
            CompressionForce = dataset.GetString(DicomTag.CompressionForce),
            BodyPartThickness = dataset.GetString(DicomTag.BodyPartThickness),
            AnodeTargetMaterial = dataset.GetString(DicomTag.AnodeTargetMaterial),
            FilterMaterial = dataset.GetString(DicomTag.FilterMaterial),
            KVP = dataset.GetString(DicomTag.KVP),
            ExposureTime = dataset.GetString(DicomTag.ExposureTime),
            OrganDose = dataset.GetString(DicomTag.OrganDose)
        };
    }

    private GenericMetadata ExtractGenericMetadata(DicomDataset dataset)
    {
        return new GenericMetadata
        {
            Modality = dataset.GetString(DicomTag.Modality),
            StudyDescription = dataset.GetString(DicomTag.StudyDescription),
            SeriesDescription = dataset.GetString(DicomTag.SeriesDescription)
        };
    }
}

// Modality-specific metadata classes
public class CtMetadata
{
    public string KVP { get; set; }
    public string XRayTubeCurrent { get; set; }
    public string ExposureTime { get; set; }
    public string SliceThickness { get; set; }
    public string SpacingBetweenSlices { get; set; }
    public string ConvolutionKernel { get; set; }
    public string GantryTilt { get; set; }
    public string TableHeight { get; set; }
    public string RotationDirection { get; set; }
    public string CTDIvol { get; set; }
    public string WindowCenter { get; set; }
    public string WindowWidth { get; set; }
}

public class MrMetadata
{
    public string MagneticFieldStrength { get; set; }
    public string SequenceName { get; set; }
    public string ScanningSequence { get; set; }
    public string SequenceVariant { get; set; }
    public string RepetitionTime { get; set; }
    public string EchoTime { get; set; }
    public string InversionTime { get; set; }
    public string FlipAngle { get; set; }
    public string SliceThickness { get; set; }
    public string EchoTrainLength { get; set; }
    public string PixelBandwidth { get; set; }
    public string ImagingFrequency { get; set; }
}

public class RadiographyMetadata
{
    public string KVP { get; set; }
    public string ExposureTime { get; set; }
    public string XRayTubeCurrent { get; set; }
    public string Exposure { get; set; }
    public string ExposureIndex { get; set; }
    public string TargetExposureIndex { get; set; }
    public string DeviationIndex { get; set; }
    public string DistanceSourceToDetector { get; set; }
    public string DistanceSourceToPatient { get; set; }
    public string Grid { get; set; }
    public string ViewPosition { get; set; }
}

public class UltrasoundMetadata
{
    public string TransducerType { get; set; }
    public string TransducerFrequency { get; set; }
    public string DepthOfScanField { get; set; }
    public string MechanicalIndex { get; set; }
    public string ThermalIndex { get; set; }
    public string FrameTime { get; set; }
    public string NumberOfFrames { get; set; }
}

public class MammographyMetadata
{
    public string ViewPosition { get; set; }
    public string ImageLaterality { get; set; }
    public string BreastImplantPresent { get; set; }
    public string CompressionForce { get; set; }
    public string BodyPartThickness { get; set; }
    public string AnodeTargetMaterial { get; set; }
    public string FilterMaterial { get; set; }
    public string KVP { get; set; }
    public string ExposureTime { get; set; }
    public string OrganDose { get; set; }
}

public class GenericMetadata
{
    public string Modality { get; set; }
    public string StudyDescription { get; set; }
    public string SeriesDescription { get; set; }
}

Applicazione Console-Based Viewer

Crea uno strumento di linea di comando per la rapida ispezione DICOM:

public class DicomViewerConsole
{
    public void DisplayMetadata(string filePath)
    {
        var viewer = new DicomMetadataViewer();
        var metadata = viewer.ExtractMetadata(filePath);
        
        Console.WriteLine("═══════════════════════════════════════════════════════════");
        Console.WriteLine("                    DICOM METADATA VIEWER                    ");
        Console.WriteLine("═══════════════════════════════════════════════════════════");
        Console.WriteLine($"File: {Path.GetFileName(filePath)}");
        Console.WriteLine();
        
        PrintSection("PATIENT INFORMATION");
        PrintField("Patient Name", metadata.PatientName);
        PrintField("Patient ID", metadata.PatientID);
        PrintField("Birth Date", FormatDate(metadata.PatientBirthDate));
        PrintField("Sex", metadata.PatientSex);
        PrintField("Age", metadata.PatientAge);
        
        PrintSection("STUDY INFORMATION");
        PrintField("Study Date", FormatDate(metadata.StudyDate));
        PrintField("Study Time", FormatTime(metadata.StudyTime));
        PrintField("Description", metadata.StudyDescription);
        PrintField("Accession #", metadata.AccessionNumber);
        PrintField("Referring MD", metadata.ReferringPhysician);
        PrintField("Study UID", metadata.StudyInstanceUID);
        
        PrintSection("SERIES INFORMATION");
        PrintField("Modality", metadata.Modality);
        PrintField("Description", metadata.SeriesDescription);
        PrintField("Series #", metadata.SeriesNumber);
        PrintField("Body Part", metadata.BodyPartExamined);
        PrintField("Series UID", metadata.SeriesInstanceUID);
        
        PrintSection("IMAGE INFORMATION");
        PrintField("Instance #", metadata.InstanceNumber);
        PrintField("Image Type", metadata.ImageType);
        PrintField("Dimensions", $"{metadata.Columns} x {metadata.Rows}");
        PrintField("Bits Stored", metadata.BitsStored);
        PrintField("Pixel Spacing", metadata.PixelSpacing);
        PrintField("SOP Instance", metadata.SOPInstanceUID);
        
        PrintSection("EQUIPMENT");
        PrintField("Manufacturer", metadata.Manufacturer);
        PrintField("Model", metadata.ManufacturerModelName);
        PrintField("Station", metadata.StationName);
        PrintField("Institution", metadata.InstitutionName);
        PrintField("Software", metadata.SoftwareVersions);
        
        Console.WriteLine("═══════════════════════════════════════════════════════════");
    }

    private void PrintSection(string title)
    {
        Console.WriteLine();
        Console.WriteLine($"─── {title} ───");
    }

    private void PrintField(string label, string value)
    {
        string displayValue = string.IsNullOrEmpty(value) ? "(not specified)" : value;
        Console.WriteLine($"  {label,-15}: {displayValue}");
    }

    private string FormatDate(string dicomDate)
    {
        if (string.IsNullOrEmpty(dicomDate) || dicomDate.Length != 8)
            return dicomDate;
        
        return $"{dicomDate.Substring(0, 4)}-{dicomDate.Substring(4, 2)}-{dicomDate.Substring(6, 2)}";
    }

    private string FormatTime(string dicomTime)
    {
        if (string.IsNullOrEmpty(dicomTime) || dicomTime.Length < 6)
            return dicomTime;
        
        return $"{dicomTime.Substring(0, 2)}:{dicomTime.Substring(2, 2)}:{dicomTime.Substring(4, 2)}";
    }
}

Web API per Metadata Retrieval

Costruisci punti finali REST per l’accesso ai metadati:

[ApiController]
[Route("api/[controller]")]
public class DicomMetadataController : ControllerBase
{
    private readonly string _uploadPath = Path.Combine(Path.GetTempPath(), "dicom_uploads");

    public DicomMetadataController()
    {
        Directory.CreateDirectory(_uploadPath);
    }

    [HttpPost("upload")]
    public async Task<IActionResult> UploadAndExtract(IFormFile file)
    {
        if (file == null || file.Length == 0)
            return BadRequest("No file provided");

        var filePath = Path.Combine(_uploadPath, $"{Guid.NewGuid()}.dcm");
        
        try
        {
            using (var stream = new FileStream(filePath, FileMode.Create))
            {
                await file.CopyToAsync(stream);
            }

            var viewer = new DicomMetadataViewer();
            var metadata = viewer.ExtractMetadata(filePath);
            
            return Ok(metadata);
        }
        finally
        {
            if (System.IO.File.Exists(filePath))
                System.IO.File.Delete(filePath);
        }
    }

    [HttpPost("tags")]
    public async Task<IActionResult> GetAllTags(IFormFile file)
    {
        if (file == null || file.Length == 0)
            return BadRequest("No file provided");

        var filePath = Path.Combine(_uploadPath, $"{Guid.NewGuid()}.dcm");
        
        try
        {
            using (var stream = new FileStream(filePath, FileMode.Create))
            {
                await file.CopyToAsync(stream);
            }

            var browser = new DicomTagBrowser();
            var tags = browser.GetAllTags(filePath);
            
            return Ok(tags);
        }
        finally
        {
            if (System.IO.File.Exists(filePath))
                System.IO.File.Delete(filePath);
        }
    }

    [HttpPost("modality-specific")]
    public async Task<IActionResult> GetModalityMetadata(IFormFile file)
    {
        if (file == null || file.Length == 0)
            return BadRequest("No file provided");

        var filePath = Path.Combine(_uploadPath, $"{Guid.NewGuid()}.dcm");
        
        try
        {
            using (var stream = new FileStream(filePath, FileMode.Create))
            {
                await file.CopyToAsync(stream);
            }

            var extractor = new ModalityMetadataExtractor();
            var data = extractor.ExtractModalitySpecificData(filePath);
            
            return Ok(data);
        }
        finally
        {
            if (System.IO.File.Exists(filePath))
                System.IO.File.Delete(filePath);
        }
    }
}

Rapporti di metadati

Generare rapporti metadati in diversi formati:

public class MetadataReportGenerator
{
    public void GenerateCsvReport(string dicomDirectory, string outputPath)
    {
        var viewer = new DicomMetadataViewer();
        var records = new List<string>();
        
        // Header
        records.Add("FileName,PatientID,PatientName,StudyDate,Modality,SeriesDescription,Rows,Columns");
        
        var files = Directory.GetFiles(dicomDirectory, "*.dcm", SearchOption.AllDirectories);
        
        foreach (var file in files)
        {
            try
            {
                var metadata = viewer.ExtractMetadata(file);
                
                var record = string.Join(",",
                    EscapeCsv(Path.GetFileName(file)),
                    EscapeCsv(metadata.PatientID),
                    EscapeCsv(metadata.PatientName),
                    EscapeCsv(metadata.StudyDate),
                    EscapeCsv(metadata.Modality),
                    EscapeCsv(metadata.SeriesDescription),
                    metadata.Rows ?? "",
                    metadata.Columns ?? "");
                
                records.Add(record);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error processing {file}: {ex.Message}");
            }
        }
        
        File.WriteAllLines(outputPath, records);
    }

    public void GenerateJsonReport(string dicomDirectory, string outputPath)
    {
        var viewer = new DicomMetadataViewer();
        var metadataList = new List<object>();
        
        var files = Directory.GetFiles(dicomDirectory, "*.dcm", SearchOption.AllDirectories);
        
        foreach (var file in files)
        {
            try
            {
                var metadata = viewer.ExtractMetadata(file);
                metadataList.Add(new
                {
                    FileName = Path.GetFileName(file),
                    Metadata = metadata
                });
            }
            catch (Exception ex)
            {
                metadataList.Add(new
                {
                    FileName = Path.GetFileName(file),
                    Error = ex.Message
                });
            }
        }
        
        var json = JsonSerializer.Serialize(metadataList, new JsonSerializerOptions 
        { 
            WriteIndented = true 
        });
        
        File.WriteAllText(outputPath, json);
    }

    private string EscapeCsv(string value)
    {
        if (string.IsNullOrEmpty(value))
            return "";
        
        if (value.Contains(",") || value.Contains("\"") || value.Contains("\n"))
        {
            return $"\"{value.Replace("\"", "\"\"")}\"";
        }
        
        return value;
    }
}

Esempio di utilizzo

class Program
{
    static void Main(string[] args)
    {
        // Activate license
        Metered metered = new Metered();
        metered.SetMeteredKey("your-public-key", "your-private-key");

        string dicomFile = @"C:\DICOM\sample.dcm";
        
        // Console viewer
        var consoleViewer = new DicomViewerConsole();
        consoleViewer.DisplayMetadata(dicomFile);
        
        // Browse all tags
        var browser = new DicomTagBrowser();
        var tags = browser.GetAllTags(dicomFile);
        
        Console.WriteLine($"\nTotal tags: {tags.Count}");
        
        // Generate report for directory
        var reportGenerator = new MetadataReportGenerator();
        reportGenerator.GenerateCsvReport(@"C:\DICOM\Studies", @"C:\Reports\metadata.csv");
    }
}

conclusione

Costruire un visualizzatore di metadati DICOM ti dà capacità essenziali per lo sviluppo dell’immagine medica. Se hai bisogno di un inspettore di linea di comando veloce, un’API web per l’integrazione, o strumenti di reporting di pacchetti, Aspose.Medical per .NET fornisce la base per estrarre e analizzare gli attributi DIKOM. Queste tecniche sono preziose per la risoluzione dei problemi, la garanzia della qualità e la costruzione di applicazioni di immagini mediche.

Per ulteriori informazioni sul lavoro con i file DICOM, visita il Aspose.documentazione medica.

More in this category