DICOM Medical Imaging Format

Overview

DICOM (Digital Imaging and Communications in Medicine) is an international standard format for medical imaging and communication. DICOM files store medical images along with comprehensive metadata including patient information, imaging parameters, and clinical context. The format is ubiquitous in healthcare for storing, transmitting, and displaying medical images from various modalities.

Technical Details

File Extensions: .dcm, .dicom, .dic
MIME Type: application/dicom
Standard: ISO 12052, NEMA PS3
Encoding: Binary with structured metadata
Image Formats: Various (JPEG, JPEG-LS, JPEG 2000, RLE, uncompressed)
Byte Order: Little-endian or Big-endian

DICOM files contain:

• Patient demographic information
• Study and series metadata
• Image acquisition parameters
• Pixel data in various formats
• Structured reports and annotations

Key Features

• Comprehensive Metadata: Rich clinical and technical information
• Multi-Modal Support: CT, MRI, X-ray, ultrasound, and more
• Lossless Compression: Preserves diagnostic quality
• Networking Protocol: DICOM communication standards
• Security Features: Patient privacy and data integrity
• 3D/4D Support: Multi-dimensional image datasets

DICOM File Structure

DICOM File Structure:
├── File Preamble (128 bytes)
├── DICOM Prefix ("DICM")
├── File Meta Information
│   ├── Transfer Syntax UID
│   ├── Media Storage SOP Class UID
│   ├── Implementation Class UID
│   └── Implementation Version Name
└── Data Set
    ├── Patient Information Module
    ├── Study Information Module
    ├── Series Information Module
    ├── Image Information Module
    ├── Equipment Information Module
    └── Pixel Data Element

Data Elements and Tags

Standard DICOM Tags

(0008,0018) - SOP Instance UID
(0008,0020) - Study Date
(0008,0030) - Study Time
(0008,0060) - Modality
(0008,1030) - Study Description

(0010,0010) - Patient Name
(0010,0020) - Patient ID
(0010,0030) - Patient Birth Date
(0010,0040) - Patient Sex

(0018,0050) - Slice Thickness
(0018,0060) - kVp
(0018,1151) - X-ray Tube Current

(0020,000D) - Study Instance UID
(0020,000E) - Series Instance UID
(0020,0013) - Instance Number

(0028,0010) - Rows
(0028,0011) - Columns
(0028,0100) - Bits Allocated
(0028,0101) - Bits Stored
(0028,0102) - High Bit
(0028,0103) - Pixel Representation

(7FE0,0010) - Pixel Data

Value Representations (VR)

AE - Application Entity
AS - Age String
AT - Attribute Tag
CS - Code String
DA - Date
DS - Decimal String
DT - Date Time
FL - Floating Point Single
FD - Floating Point Double
IS - Integer String
LO - Long String
LT - Long Text
OB - Other Byte
OF - Other Float
OW - Other Word
PN - Person Name
SH - Short String
SL - Signed Long
SQ - Sequence of Items
SS - Signed Short
ST - Short Text
TM - Time
UI - Unique Identifier
UL - Unsigned Long
UN - Unknown
US - Unsigned Short
UT - Unlimited Text

Common Use Cases

1. Medical Imaging: CT, MRI, X-ray, ultrasound storage
2. Picture Archiving: PACS systems
3. Teleradiology: Remote image consultation
4. Research Studies: Clinical and academic research
5. AI/ML Training: Medical image analysis datasets
6. ** 3D Reconstruction:** Volumetric image processing

Working with DICOM Files

Python (pydicom)

import pydicom
import numpy as np
from PIL import Image
import matplotlib.pyplot as plt

# Read DICOM file
def read_dicom(filepath):
    """Read and display basic DICOM information."""
    ds = pydicom.dcmread(filepath)
    
    print(f"Patient Name: {ds.PatientName}")
    print(f"Patient ID: {ds.PatientID}")
    print(f"Modality: {ds.Modality}")
    print(f"Study Date: {ds.StudyDate}")
    print(f"Study Description: {ds.StudyDescription}")
    print(f"Image Size: {ds.Rows} x {ds.Columns}")
    print(f"Pixel Spacing: {ds.PixelSpacing}")
    
    return ds

# Extract and display image
def display_dicom_image(ds):
    """Extract and display DICOM image data."""
    # Get pixel array
    pixel_array = ds.pixel_array
    
    # Apply window/level if present
    if hasattr(ds, 'WindowCenter') and hasattr(ds, 'WindowWidth'):
        window_center = ds.WindowCenter
        window_width = ds.WindowWidth
        
        if isinstance(window_center, pydicom.multival.MultiValue):
            window_center = window_center[0]
            window_width = window_width[0]
        
        # Apply windowing
        img_min = window_center - window_width // 2
        img_max = window_center + window_width // 2
        pixel_array = np.clip(pixel_array, img_min, img_max)
    
    # Display image
    plt.figure(figsize=(10, 10))
    plt.imshow(pixel_array, cmap='gray')
    plt.title(f"{ds.StudyDescription} - {ds.Modality}")
    plt.axis('off')
    plt.show()

# Modify DICOM metadata
def anonymize_dicom(ds):
    """Remove patient identifying information."""
    # Remove patient information
    ds.PatientName = "ANONYMOUS"
    ds.PatientID = "ANON001"
    ds.PatientBirthDate = ""
    ds.PatientSex = ""
    
    # Remove study information
    if hasattr(ds, 'StudyDescription'):
        ds.StudyDescription = "ANONYMIZED STUDY"
    
    # Generate new UIDs
    ds.StudyInstanceUID = pydicom.uid.generate_uid()
    ds.SeriesInstanceUID = pydicom.uid.generate_uid()
    ds.SOPInstanceUID = pydicom.uid.generate_uid()
    
    return ds

# Convert to common formats
def dicom_to_png(ds, output_path):
    """Convert DICOM to PNG format."""
    pixel_array = ds.pixel_array
    
    # Normalize to 8-bit
    if pixel_array.dtype != np.uint8:
        pixel_array = ((pixel_array - pixel_array.min()) * 255.0 / 
                      (pixel_array.max() - pixel_array.min())).astype(np.uint8)
    
    # Save as PNG
    image = Image.fromarray(pixel_array)
    image.save(output_path)

# Example usage
ds = read_dicom('sample.dcm')
display_dicom_image(ds)
anonymized_ds = anonymize_dicom(ds)
pydicom.dcmwrite('anonymized.dcm', anonymized_ds)
dicom_to_png(ds, 'output.png')

Processing Multiple DICOM Files

import os
import pydicom
from pathlib import Path

def process_dicom_series(directory):
    """Process a series of DICOM files."""
    dicom_files = []
    
    # Find all DICOM files
    for root, dirs, files in os.walk(directory):
        for file in files:
            if file.lower().endswith(('.dcm', '.dicom')):
                filepath = os.path.join(root, file)
                try:
                    ds = pydicom.dcmread(filepath)
                    dicom_files.append((filepath, ds))
                except:
                    print(f"Failed to read: {filepath}")
    
    # Sort by instance number
    dicom_files.sort(key=lambda x: int(x[1].InstanceNumber) if hasattr(x[1], 'InstanceNumber') else 0)
    
    # Create 3D volume
    volume_data = []
    for filepath, ds in dicom_files:
        volume_data.append(ds.pixel_array)
    
    volume = np.stack(volume_data, axis=0)
    return volume, dicom_files

def create_volume_visualization(volume):
    """Create 3D visualization of DICOM volume."""
    import matplotlib.pyplot as plt
    from mpl_toolkits.mplot3d import Axes3D
    
    # Create figure with subplots
    fig, axes = plt.subplots(2, 2, figsize=(12, 12))
    
    # Axial view (top-down)
    axes[0, 0].imshow(volume[volume.shape[0]//2], cmap='gray')
    axes[0, 0].set_title('Axial View')
    axes[0, 0].axis('off')
    
    # Sagittal view (side)
    axes[0, 1].imshow(volume[:, :, volume.shape[2]//2], cmap='gray')
    axes[0, 1].set_title('Sagittal View')
    axes[0, 1].axis('off')
    
    # Coronal view (front)
    axes[1, 0].imshow(volume[:, volume.shape[1]//2, :], cmap='gray')
    axes[1, 0].set_title('Coronal View')
    axes[1, 0].axis('off')
    
    # Volume histogram
    axes[1, 1].hist(volume.flatten(), bins=50, alpha=0.7)
    axes[1, 1].set_title('Intensity Histogram')
    axes[1, 1].set_xlabel('Intensity')
    axes[1, 1].set_ylabel('Frequency')
    
    plt.tight_layout()
    plt.show()

Command Line Tools

DCMTK (DICOM Toolkit)

# Display DICOM information
dcmdump sample.dcm

# Display specific tags
dcmdump +P 0010,0010 sample.dcm  # Patient Name
dcmdump +P 0008,0060 sample.dcm  # Modality

# Convert DICOM to image formats
dcmj2pnm +oj sample.dcm output.jpg
dcm2pnm sample.dcm output.ppm

# Anonymize DICOM files
dcmodify --modify "(0010,0010)=ANONYMOUS" sample.dcm
dcmodify --modify "(0010,0020)=ANON001" sample.dcm

# Validate DICOM files
dciodvfy sample.dcm

# Query/Retrieve operations
findscu -v -P -k 0008,0052=STUDY -k 0010,0020 pacs.hospital.com 104

# Send DICOM files
storescu -v pacs.hospital.com 104 sample.dcm

ImageJ/Fiji

// ImageJ Macro for DICOM processing
open("sample.dcm");
run("Enhance Contrast", "saturated=0.35");
run("Apply LUT");
saveAs("PNG", "output.png");

// Batch processing
dir = getDirectory("Choose DICOM Directory");
list = getFileList(dir);
for (i=0; i<list.length; i++) {
    if (endsWith(list[i], ".dcm")) {
        open(dir + list[i]);
        run("8-bit");
        saveAs("PNG", dir + "processed_" + i + ".png");
        close();
    }
}

DICOM Networking

DICOM C-STORE (Storage)

from pynetdicom import AE, evt
from pynetdicom.sop_class import CTImageStorage
import pydicom

# Storage SCP (Server)
def handle_store(event):
    """Handle incoming DICOM storage request."""
    ds = event.dataset
    
    # Save DICOM file
    filename = f"{ds.SOPInstanceUID}.dcm"
    ds.file_meta = event.file_meta
    ds.save_as(filename, write_like_original=False)
    
    print(f"Stored: {filename}")
    return 0x0000  # Success

# Create Application Entity
ae = AE()
ae.add_supported_context(CTImageStorage)
ae.add_supported_context('1.2.840.10008.1.1')  # Verification SOP Class

# Start SCP
handlers = [(evt.EVT_C_STORE, handle_store)]
ae.start_server(('', 11112), block=True, evt_handlers=handlers)

# Storage SCU (Client)
def send_dicom(filename, host, port):
    """Send DICOM file to PACS."""
    ds = pydicom.dcmread(filename)
    
    ae = AE()
    ae.add_requested_context(ds.SOPClassUID)
    
    # Associate with PACS
    assoc = ae.associate(host, port)
    if assoc.is_established:
        status = assoc.send_c_store(ds)
        if status:
            print(f"C-STORE request status: 0x{status.Status:04x}")
        assoc.release()
    else:
        print("Association rejected, aborted or never connected")

DICOM C-FIND (Query)

from pynetdicom.sop_class import StudyRootQueryRetrieveInformationModelFind

def query_studies(host, port, patient_id):
    """Query PACS for studies."""
    # Create identifier dataset
    ds = pydicom.Dataset()
    ds.QueryRetrieveLevel = 'STUDY'
    ds.PatientID = patient_id
    ds.StudyInstanceUID = ''
    ds.StudyDate = ''
    ds.StudyDescription = ''
    ds.PatientName = ''
    
    ae = AE()
    ae.add_requested_context(StudyRootQueryRetrieveInformationModelFind)
    
    # Associate and query
    assoc = ae.associate(host, port)
    if assoc.is_established:
        responses = assoc.send_c_find(ds, StudyRootQueryRetrieveInformationModelFind)
        
        for status, identifier in responses:
            if status:
                if status.Status in (0xFF00, 0xFF01):
                    # Pending response
                    print(f"Study: {identifier.StudyDescription}")
                    print(f"Date: {identifier.StudyDate}")
                    print(f"UID: {identifier.StudyInstanceUID}")
                    print("---")
            else:
                print("Connection timed out, was aborted or received invalid response")
        
        assoc.release()

Advanced Processing

DICOM-RT (Radiation Therapy)

def process_rt_structure_set(filepath):
    """Process DICOM RT Structure Set."""
    ds = pydicom.dcmread(filepath)
    
    if ds.Modality != 'RTSTRUCT':
        raise ValueError("Not an RT Structure Set")
    
    # Extract ROI information
    roi_info = {}
    for roi in ds.StructureSetROISequence:
        roi_number = roi.ROINumber
        roi_name = roi.ROIName
        roi_info[roi_number] = {
            'name': roi_name,
            'contours': []
        }
    
    # Extract contour data
    for roi_contour in ds.ROIContourSequence:
        roi_number = roi_contour.ReferencedROINumber
        
        if hasattr(roi_contour, 'ContourSequence'):
            for contour in roi_contour.ContourSequence:
                contour_data = np.array(contour.ContourData).reshape(-1, 3)
                roi_info[roi_number]['contours'].append(contour_data)
    
    return roi_info

# Dose distribution analysis
def analyze_dose_distribution(dose_filepath, struct_filepath):
    """Analyze dose distribution within structures."""
    dose_ds = pydicom.dcmread(dose_filepath)
    dose_array = dose_ds.pixel_array
    
    # Apply dose scaling
    if hasattr(dose_ds, 'DoseGridScaling'):
        dose_array = dose_array * dose_ds.DoseGridScaling
    
    roi_info = process_rt_structure_set(struct_filepath)
    
    # Calculate dose statistics for each ROI
    dose_stats = {}
    for roi_number, roi_data in roi_info.items():
        # Convert contours to mask (simplified)
        mask = create_roi_mask(roi_data['contours'], dose_array.shape)
        roi_dose = dose_array[mask]
        
        dose_stats[roi_data['name']] = {
            'mean': np.mean(roi_dose),
            'max': np.max(roi_dose),
            'min': np.min(roi_dose),
            'std': np.std(roi_dose)
        }
    
    return dose_stats

Image Enhancement and Analysis

def enhance_dicom_image(ds):
    """Apply various enhancement techniques to DICOM image."""
    pixel_array = ds.pixel_array.astype(np.float64)
    
    # Histogram equalization
    from skimage import exposure
    enhanced = exposure.equalize_hist(pixel_array)
    
    # Gaussian filter for noise reduction
    from scipy import ndimage
    smoothed = ndimage.gaussian_filter(enhanced, sigma=1.0)
    
    # Edge enhancement
    from skimage import filters
    edges = filters.sobel(smoothed)
    
    # Combine original and enhanced
    result = 0.7 * smoothed + 0.3 * edges
    
    return result

def segment_organs(pixel_array):
    """Simple organ segmentation using thresholding."""
    # Otsu's thresholding
    from skimage import filters, measure
    
    threshold = filters.threshold_otsu(pixel_array)
    binary = pixel_array > threshold
    
    # Label connected components
    labeled = measure.label(binary)
    
    # Filter by size
    regions = measure.regionprops(labeled)
    large_regions = [r for r in regions if r.area > 1000]
    
    return labeled, large_regions

Security and Privacy

DICOM Anonymization

def comprehensive_anonymization(ds):
    """Comprehensive DICOM anonymization."""
    # Patient identification
    ds.PatientName = "ANONYMOUS"
    ds.PatientID = "ANON" + pydicom.uid.generate_uid()[-10:]
    ds.PatientBirthDate = ""
    ds.PatientSex = ""
    ds.PatientAge = ""
    ds.PatientWeight = ""
    ds.PatientSize = ""
    
    # Study identification
    ds.StudyID = "ANON_STUDY"
    ds.StudyDescription = "ANONYMIZED"
    ds.StudyDate = "19000101"
    ds.StudyTime = "000000"
    
    # Remove private tags
    ds.remove_private_tags()
    
    # Generate new UIDs
    ds.StudyInstanceUID = pydicom.uid.generate_uid()
    ds.SeriesInstanceUID = pydicom.uid.generate_uid()
    ds.SOPInstanceUID = pydicom.uid.generate_uid()
    
    # Remove operator identification
    if hasattr(ds, 'OperatorsName'):
        ds.OperatorsName = ""
    if hasattr(ds, 'PerformingPhysicianName'):
        ds.PerformingPhysicianName = ""
    
    return ds

Performance Optimization

Efficient DICOM Reading

def fast_dicom_metadata_extraction(directory):
    """Fast extraction of DICOM metadata without loading pixel data."""
    metadata = []
    
    for filepath in Path(directory).glob("*.dcm"):
        # Read without pixel data
        ds = pydicom.dcmread(filepath, stop_before_pixels=True)
        
        metadata.append({
            'filepath': str(filepath),
            'patient_id': getattr(ds, 'PatientID', ''),
            'study_date': getattr(ds, 'StudyDate', ''),
            'modality': getattr(ds, 'Modality', ''),
            'series_number': getattr(ds, 'SeriesNumber', ''),
            'instance_number': getattr(ds, 'InstanceNumber', '')
        })
    
    return metadata

def lazy_pixel_loading(filepath):
    """Load pixel data only when needed."""
    class LazyDICOM:
        def __init__(self, filepath):
            self.filepath = filepath
            self._ds = None
            self._pixel_array = None
        
        @property
        def metadata(self):
            if self._ds is None:
                self._ds = pydicom.dcmread(self.filepath, stop_before_pixels=True)
            return self._ds
        
        @property
        def pixel_array(self):
            if self._pixel_array is None:
                full_ds = pydicom.dcmread(self.filepath)
                self._pixel_array = full_ds.pixel_array
            return self._pixel_array
    
    return LazyDICOM(filepath)

DICOM format represents the cornerstone of medical imaging, providing a comprehensive framework for storing, transmitting, and processing medical images while maintaining rich clinical context and ensuring interoperability across different healthcare systems and imaging modalities.