Compress/resize DICOM pixel data before storing to PACS (#10)

Compress and resize pixel data when storing DICOM image

Author: carlosmartinez

.gitleaksignore

@@ -8,12 +8,20 @@
 
 
 src/services/storage.py:ipv4:74
+tests/services/dicom/test_c_store.py:ipv4:15
+tests/services/dicom/test_c_store.py:ipv4:19
+tests/services/dicom/test_c_store.py:ipv4:48
+tests/services/dicom/test_c_store.py:ipv4:62
 tests/integration/test_c_store_saves_metadata.py:ipv4:21
+tests/integration/test_c_store_saves_metadata.py:ipv4:23
+tests/integration/test_c_store_saves_metadata.py:ipv4:38
 tests/integration/test_c_store_saves_metadata.py:ipv4:41
 tests/integration/test_c_store_saves_metadata.py:ipv4:52
+tests/integration/test_c_store_saves_metadata.py:ipv4:55
 tests/integration/test_c_store_saves_metadata.py:ipv4:65
-tests/services/dicom/test_c_store.py:ipv4:15
-tests/services/dicom/test_c_store.py:ipv4:48
+tests/integration/test_c_store_saves_metadata.py:ipv4:73
+tests/integration/test_c_store_saves_metadata.py:ipv4:91
+tests/integration/test_c_store_saves_metadata.py:ipv4:108
 tests/services/test_storage.py:ipv4:37
 tests/services/test_storage.py:ipv4:40
 tests/services/test_storage.py:ipv4:52

pyproject.toml

@@ -8,6 +8,11 @@ license = { text = "MIT" }
 dependencies = [
   "pydicom>=3.0.1",
   "pynetdicom>=3.0.4",
+  "numpy>=2.4.0,<3",
+  "pylibjpeg>=2.0.0",
+  "pylibjpeg-libjpeg>=2.0.0",
+  "pylibjpeg-openjpeg>=2.2.0",
+  "pillow>=11.0.0",
 ]
 
 [dependency-groups]
@@ -17,7 +22,6 @@ dev = [
   "ruff>=0.14.1,<0.15",
   "pyright>=1.1.390",
   "ipdb>=0.13.13,<0.14",
-  "numpy>=2.4.0,<3",
 ]
 
 [tool.uv]

src/services/dicom/c_store.py

@@ -10,6 +10,7 @@
 )
 
 from services.dicom import FAILURE, SUCCESS
+from services.dicom.image_compressor import ImageCompressor
 from services.storage import InstanceExistsError, PACSStorage
 
 logger = logging.getLogger(__name__)
@@ -21,8 +22,9 @@ class CStore:
         DigitalMammographyXRayImageStorageForProcessing,
     ]
 
-    def __init__(self, storage: PACSStorage):
+    def __init__(self, storage: PACSStorage, compressor: ImageCompressor | None = None):
         self.storage = storage
+        self.compressor = compressor or ImageCompressor()
 
     def call(self, event: Event) -> int:
         try:
@@ -46,9 +48,12 @@ def call(self, event: Event) -> int:
             accession_number = ds.get("AccessionNumber", "")
             patient_name = str(ds.get("PatientName", ""))
 
+            # Compress dataset before storing
+            compressed_ds = self.compressor.compress(ds)
+
             self.storage.store_instance(
                 sop_instance_uid,
-                self.dataset_to_bytes(ds),
+                self.dataset_to_bytes(compressed_ds),
                 {
                     "accession_number": accession_number,
                     "patient_id": patient_id,

src/services/dicom/image_compressor.py

@@ -0,0 +1,73 @@
+"""DICOM Image Compression Service
+
+Provides compression functionality for DICOM images using JPEG 2000 Lossy compression.
+"""
+
+import logging
+import os
+
+from pydicom import Dataset
+from pydicom.pixels.utils import compress
+from pydicom.uid import JPEG2000, ExplicitVRBigEndian, ExplicitVRLittleEndian, ImplicitVRLittleEndian
+
+from services.dicom.image_resizer import ImageResizer
+
+# Uncompressed DICOM transfer syntaxes
+UNCOMPRESSED_TRANSFER_SYNTAXES = {ExplicitVRLittleEndian, ImplicitVRLittleEndian, ExplicitVRBigEndian}
+
+logger = logging.getLogger(__name__)
+
+
+class ImageCompressor:
+    def __init__(self, compression_ratio: int | None = None, resizer: ImageResizer | None = None):
+        self.compression_ratio = (
+            compression_ratio if compression_ratio is not None else int(os.getenv("DICOM_COMPRESSION_RATIO", "15"))
+        )
+        self.resizer = resizer or ImageResizer()
+
+    def compress(self, ds: Dataset) -> Dataset:
+        """
+        Resize and compress DICOM image.
+
+        Args:
+            ds: DICOM dataset
+
+        Returns:
+            Best possible version of dataset given any failures
+        """
+        if not hasattr(ds, "PixelData") or ds.PixelData is None:
+            logger.info("No pixel data found, skipping compression")
+            return ds
+
+        # Decompress if already compressed
+        if ds.file_meta.TransferSyntaxUID not in UNCOMPRESSED_TRANSFER_SYNTAXES:
+            try:
+                logger.info(f"Decompressing from {ds.file_meta.TransferSyntaxUID.name}")
+                ds.decompress()
+            except Exception as e:
+                logger.error(f"Decompression failed: {e}", exc_info=True)
+                logger.warning("Continuing with compressed dataset")
+
+        try:
+            ds = self.resizer.resize(ds)
+            logger.debug(f"Resized to {ds.Columns}×{ds.Rows}")
+        except Exception as e:
+            logger.error(f"Resizing failed: {e}", exc_info=True)
+            logger.warning("Continuing with original size")
+
+        try:
+            compressed_ds = compress(
+                ds, transfer_syntax_uid=JPEG2000, encoding_plugin="pylibjpeg", j2k_cr=[self.compression_ratio]
+            )
+            logger.info(
+                f"Compressed to {compressed_ds.file_meta.TransferSyntaxUID.name} "
+                f"({self.compression_ratio}:1, {compressed_ds.Columns}×{compressed_ds.Rows})"
+            )
+            return compressed_ds
+
+        except Exception as e:
+            logger.error(f"Compression failed: {e}", exc_info=True)
+            logger.warning(
+                f"Returning uncompressed dataset ({ds.Columns}×{ds.Rows}, ~{(ds.Columns * ds.Rows * 2) / 1024:.0f} KB)"
+            )
+            return ds

src/services/dicom/image_resizer.py

@@ -0,0 +1,99 @@
+"""DICOM Image Resizing Service
+
+Provides resizing functionality for DICOM images while maintaining aspect ratio.
+"""
+
+import logging
+import os
+
+import numpy as np
+from PIL import Image
+from pydicom import Dataset
+
+logger = logging.getLogger(__name__)
+
+
+class ImageResizer:
+    def __init__(self, thumbnail_size: int | None = None):
+        self.thumbnail_size = (
+            thumbnail_size if thumbnail_size is not None else int(os.getenv("DICOM_THUMBNAIL_SIZE", "400"))
+        )
+
+    def _calculate_thumbnail_dimensions(self, original_cols: int, original_rows: int) -> tuple[int, int]:
+        aspect_ratio = original_cols / original_rows
+        if original_cols > original_rows:
+            new_cols = self.thumbnail_size
+            new_rows = int(self.thumbnail_size / aspect_ratio)
+        else:
+            new_rows = self.thumbnail_size
+            new_cols = int(self.thumbnail_size * aspect_ratio)
+        return new_cols, new_rows
+
+    def _to_pil_image(self, pixel_array: np.ndarray, bits_allocated: int) -> tuple[Image.Image, dict]:
+        normalization_info = {}
+
+        if bits_allocated == 16:
+            pixel_min = pixel_array.min()
+            pixel_max = pixel_array.max()
+            normalization_info = {"pixel_min": pixel_min, "pixel_max": pixel_max}
+
+            if pixel_max > pixel_min:
+                pixel_array_8bit = ((pixel_array - pixel_min) / (pixel_max - pixel_min) * 255).astype(np.uint8)
+            else:
+                # Handle uniform images (all same value)
+                pixel_array_8bit = np.zeros_like(pixel_array, dtype=np.uint8)
+            img = Image.fromarray(pixel_array_8bit, mode="L")
+        else:
+            img = Image.fromarray(pixel_array, mode="L")
+
+        return img, normalization_info
+
+    def _from_pil_image(self, img: Image.Image, bits_allocated: int, normalization_info: dict) -> np.ndarray:
+        resized_array = np.array(img)
+
+        # For 16-bit images, scale back to 16-bit range
+        if bits_allocated == 16:
+            pixel_min = normalization_info.get("pixel_min", 0)
+            pixel_max = normalization_info.get("pixel_max", 0)
+
+            if pixel_max > pixel_min:
+                resized_array = (resized_array.astype(np.float32) / 255 * (pixel_max - pixel_min) + pixel_min).astype(
+                    np.uint16
+                )
+            else:
+                # Keep uniform image as is
+                resized_array = resized_array.astype(np.uint16)
+
+        return resized_array
+
+    def resize(self, ds: Dataset) -> Dataset:
+        original_rows = ds.Rows
+        original_cols = ds.Columns
+
+        # Skip if already smaller than thumbnail size
+        if original_rows <= self.thumbnail_size and original_cols <= self.thumbnail_size:
+            logger.info(
+                f"Image {original_cols}x{original_rows} already smaller than {self.thumbnail_size}, skipping resize"
+            )
+            return ds
+
+        # Calculate new dimensions
+        new_cols, new_rows = self._calculate_thumbnail_dimensions(original_cols, original_rows)
+        logger.info(f"Resizing from {original_cols}x{original_rows} to {new_cols}x{new_rows}")
+
+        # Convert DICOM to PIL Image
+        pixel_array = ds.pixel_array
+        img, normalization_info = self._to_pil_image(pixel_array, ds.BitsAllocated)
+
+        # Resize
+        img_resized = img.resize((new_cols, new_rows), Image.Resampling.LANCZOS)
+
+        # Convert back to DICOM pixel data
+        resized_array = self._from_pil_image(img_resized, ds.BitsAllocated, normalization_info)
+
+        # Update dataset
+        ds.PixelData = resized_array.tobytes()
+        ds.Rows = new_rows
+        ds.Columns = new_cols
+
+        return ds

tests/conftest.py

@@ -2,7 +2,13 @@
 import sys
 from pathlib import Path
 
+import numpy as np
 import pytest
+from pydicom import Dataset, FileMetaDataset
+from pydicom.uid import ExplicitVRLittleEndian
+from pynetdicom.sop_class import (
+    DigitalMammographyXRayImageStorageForPresentation,
+)
 
 sys.path.append(f"{Path(__file__).parent.parent}/src")
 
@@ -27,3 +33,40 @@ def normalize(sql: str) -> str:
     assert normalize(expected) == normalize(actual), (
         f"SQL statements do not match. Expected:\n{normalize(expected)}\n\nActual:\n{normalize(actual)}"
     )
+
+
+# DICOM test fixtures
+@pytest.fixture
+def dicom_file_meta():
+    """Create standard DICOM file meta information."""
+    file_meta = FileMetaDataset()
+    file_meta.TransferSyntaxUID = ExplicitVRLittleEndian
+    file_meta.MediaStorageSOPClassUID = DigitalMammographyXRayImageStorageForPresentation
+    return file_meta
+
+
+@pytest.fixture
+def dataset_with_pixels(dicom_file_meta):
+    """Create a DICOM dataset with pixel data (256x256, 16-bit)."""
+    ds = Dataset()
+    ds.Rows = 256
+    ds.Columns = 256
+    ds.BitsAllocated = 16
+    ds.BitsStored = 16
+    ds.HighBit = 15
+    ds.PixelRepresentation = 0
+    ds.SamplesPerPixel = 1
+    ds.PhotometricInterpretation = "MONOCHROME2"
+    ds.PixelData = np.zeros((256, 256), dtype=np.uint16).tobytes()
+    ds.file_meta = dicom_file_meta
+    return ds
+
+
+@pytest.fixture
+def dataset_without_pixels(dicom_file_meta):
+    """Create a DICOM dataset without pixel data."""
+    ds = Dataset()
+    ds.PatientID = "123456"
+    ds.PatientName = "TEST^PATIENT"
+    ds.file_meta = dicom_file_meta
+    return ds

tests/integration/test_c_store_saves_metadata.py

@@ -1,9 +1,10 @@
 from pathlib import Path
 from unittest.mock import PropertyMock
 
+import pydicom
 import pytest
 from pydicom import Dataset, FileMetaDataset
-from pydicom.uid import ExplicitVRLittleEndian
+from pydicom.uid import JPEG2000, ExplicitVRLittleEndian
 from pynetdicom.sop_class import (
     DigitalMammographyXRayImageStorageForProcessing,
 )
@@ -81,3 +82,39 @@ def test_valid_event_is_stored(self, storage, mock_event):
             assert source_aet == "ae-title"
             assert storage_path == "ff/af/ffaff041ab509297.dcm"
             assert Path(f"{storage.storage_root}/{storage_path}").is_file()
+
+    def test_compressed_image_stored_on_filesystem(self, storage, dataset_with_pixels):
+        """Verify compressed images are stored with JPEG 2000 transfer syntax."""
+        # Customize the shared dataset for this test
+        dataset_with_pixels.AccessionNumber = "DEF456"
+        dataset_with_pixels.PatientID = "9990002223"
+        dataset_with_pixels.SOPInstanceUID = "1.2.3.4.5.7"
+
+        # Wrap in PropertyMock to simulate DICOM event
+        event = PropertyMock()
+        event.file_meta = dataset_with_pixels.file_meta
+        event.dataset = dataset_with_pixels
+        event.assoc.requestor.ae_title = "test-ae"
+
+        subject = CStore(storage)
+        assert subject.call(event) == SUCCESS
+
+        # Verify stored file has JPEG 2000 compression
+        with storage._get_connection() as conn:
+            cursor = conn.execute(
+                """
+                    SELECT storage_path
+                    FROM   stored_instances
+                    WHERE  sop_instance_uid = '1.2.3.4.5.7'
+                """
+            )
+            result = cursor.fetchone()
+
+        assert result is not None
+        storage_path = result[0]
+        stored_file = Path(storage.storage_root) / storage_path
+        assert stored_file.exists()
+
+        # Read with force=True since DicomFileLike doesn't write preamble
+        stored_ds = pydicom.dcmread(stored_file, force=True)
+        assert stored_ds.file_meta.TransferSyntaxUID == JPEG2000