Skip datasets without pixel data

Signed-off-by: Joaquin Anton Guirao <janton@nvidia.com>

Author: jantonguirao

monailabel/datastore/utils/convert_htj2k.py

@@ -507,7 +507,9 @@ def transcode_dicom_to_htj2k(
             has_pixel_data = hasattr(ds, "PixelData") and ds.PixelData is not None
             if ts_str in skip_transfer_syntaxes or not has_pixel_data:
                 skip_batch.append(idx)
-                logger.info(f"  Skipping {os.path.basename(batch_in[idx])} (Transfer Syntax: {ts_str}, has_pixel_data: {has_pixel_data})")
+                logger.info(
+                    f"  Skipping {os.path.basename(batch_in[idx])} (Transfer Syntax: {ts_str}, has_pixel_data: {has_pixel_data})"
+                )
                 continue
 
             assert has_pixel_data, f"DICOM file {os.path.basename(batch_in[idx])} does not have a PixelData member"
@@ -918,6 +920,22 @@ def convert_single_frame_dicom_series_to_multiframe(
             file_paths = [fp for _, fp in file_list]
             datasets = [pydicom.dcmread(fp) for fp in file_paths]
 
+            # Filter out datasets without PixelData (e.g., DICOM SR, Presentation States, corrupted files)
+            datasets_with_pixels = []
+            for idx, ds in enumerate(datasets):
+                if hasattr(ds, "PixelData") and ds.PixelData is not None:
+                    datasets_with_pixels.append(ds)
+                else:
+                    logger.warning(f"  Skipping file {file_paths[idx]} (no PixelData found)")
+
+            if not datasets_with_pixels:
+                logger.error(f"  Series {series_uid}: No valid datasets with PixelData found, skipping series")
+                continue
+
+            # Replace datasets with filtered list
+            datasets = datasets_with_pixels
+            logger.info(f"  Loaded {len(datasets)} valid datasets with PixelData")
+
             # CRITICAL: Sort datasets by ImagePositionPatient Z-coordinate
             # This ensures Frame[0] is the first slice, Frame[N] is the last slice
             if all(hasattr(ds, "ImagePositionPatient") for ds in datasets):
@@ -946,9 +964,11 @@ def convert_single_frame_dicom_series_to_multiframe(
                 logger.info(f"  Using original transfer syntax: {target_transfer_syntax}")
 
             # Check if we're dealing with encapsulated (compressed) data
+            has_pixel_data = hasattr(template_ds, "PixelData") and template_ds.PixelData is not None
+            # At this point we have filtered out datasets without PixelData, so this should never happen
+            assert has_pixel_data, f"Template dataset {file_paths[0]} does not have a PixelData member"
             is_encapsulated = (
-                hasattr(template_ds, "PixelData")
-                and template_ds.file_meta.TransferSyntaxUID != pydicom.uid.ExplicitVRLittleEndian
+                has_pixel_data and template_ds.file_meta.TransferSyntaxUID != pydicom.uid.ExplicitVRLittleEndian
             )
 
             # Determine color_spec for this series based on PhotometricInterpretation
@@ -994,21 +1014,22 @@ def convert_single_frame_dicom_series_to_multiframe(
                 if first_ts in NVIMGCODEC_SYNTAXES or pydicom.encaps.encapsulate_extended:
                     # Encapsulated data - extract compressed frames
                     for ds in datasets:
-                        if hasattr(ds, "PixelData"):
-                            try:
-                                # Extract compressed frames
-                                frames = [fragment for fragment in pydicom.encaps.generate_frames(ds.PixelData)]
-                                all_frames.extend(frames)
-                            except:
-                                # Fall back to pixel_array for uncompressed
-                                pixel_array = ds.pixel_array
-                                if not isinstance(pixel_array, np.ndarray):
-                                    pixel_array = np.array(pixel_array)
-                                if pixel_array.ndim == 2:
-                                    all_frames.append(pixel_array)
-                                elif pixel_array.ndim == 3:
-                                    for frame_idx in range(pixel_array.shape[0]):
-                                        all_frames.append(pixel_array[frame_idx, :, :])
+                        has_pixel_data = hasattr(ds, "PixelData") and ds.PixelData is not None
+                        assert has_pixel_data, f"Dataset {file_paths[idx]} does not have a PixelData member"
+                        try:
+                            # Extract compressed frames
+                            frames = [fragment for fragment in pydicom.encaps.generate_frames(ds.PixelData)]
+                            all_frames.extend(frames)
+                        except:
+                            # Fall back to pixel_array for uncompressed
+                            pixel_array = ds.pixel_array
+                            if not isinstance(pixel_array, np.ndarray):
+                                pixel_array = np.array(pixel_array)
+                            if pixel_array.ndim == 2:
+                                all_frames.append(pixel_array)
+                            elif pixel_array.ndim == 3:
+                                for frame_idx in range(pixel_array.shape[0]):
+                                    all_frames.append(pixel_array[frame_idx, :, :])
                 else:
                     # Uncompressed data - use pixel arrays
                     for ds in datasets:
@@ -1049,9 +1070,13 @@ def convert_single_frame_dicom_series_to_multiframe(
             # Save ImageOrientationPatient and ImagePositionPatient BEFORE creating output_ds
             # The shallow copy + delattr will affect the original datasets objects
             # Save these values now so we can use them in functional groups later
-            original_image_orientation = datasets[0].ImageOrientationPatient if hasattr(datasets[0], "ImageOrientationPatient") else None
-            original_image_positions = [ds.ImagePositionPatient if hasattr(ds, "ImagePositionPatient") else None for ds in datasets]
-            
+            original_image_orientation = (
+                datasets[0].ImageOrientationPatient if hasattr(datasets[0], "ImageOrientationPatient") else None
+            )
+            original_image_positions = [
+                ds.ImagePositionPatient if hasattr(ds, "ImagePositionPatient") else None for ds in datasets
+            ]
+
             # Create SIMPLE multi-frame DICOM file (like the user's example)
             # Use first dataset as template, keeping its metadata
             logger.info(f"  Creating simple multi-frame DICOM from {total_frame_count} frames...")
@@ -1108,19 +1133,28 @@ def convert_single_frame_dicom_series_to_multiframe(
             # CRITICAL: Remove top-level ImagePositionPatient and ImageOrientationPatient
             # Working files (that display correctly in OHIF MPR) have NEITHER at top level
             # These should ONLY exist in functional groups for Enhanced CT
-            
+
             if hasattr(output_ds, "ImagePositionPatient"):
                 delattr(output_ds, "ImagePositionPatient")
                 logger.info(f"  ✓ Removed top-level ImagePositionPatient (use per-frame only)")
-            
+
             if hasattr(output_ds, "ImageOrientationPatient"):
                 delattr(output_ds, "ImageOrientationPatient")
                 logger.info(f"  ✓ Removed top-level ImageOrientationPatient (use SharedFunctionalGroupsSequence only)")
             # Set correct SOPClassUID for multi-frame (Enhanced/Multiframe) conversion
             sopclass_map = {
-                "1.2.840.10008.5.1.4.1.1.2":   ("1.2.840.10008.5.1.4.1.1.2.1",   "Enhanced CT Image Storage"),                  # CT -> Enhanced CT
-                "1.2.840.10008.5.1.4.1.1.4":   ("1.2.840.10008.5.1.4.1.1.4.1",   "Enhanced MR Image Storage"),                  # MR -> Enhanced MR
-                "1.2.840.10008.5.1.4.1.1.6.1": ("1.2.840.10008.5.1.4.1.1.3.1",   "Ultrasound Multi-frame Image Storage"),       # US -> Ultrasound Multi-frame
+                "1.2.840.10008.5.1.4.1.1.2": (
+                    "1.2.840.10008.5.1.4.1.1.2.1",
+                    "Enhanced CT Image Storage",
+                ),  # CT -> Enhanced CT
+                "1.2.840.10008.5.1.4.1.1.4": (
+                    "1.2.840.10008.5.1.4.1.1.4.1",
+                    "Enhanced MR Image Storage",
+                ),  # MR -> Enhanced MR
+                "1.2.840.10008.5.1.4.1.1.6.1": (
+                    "1.2.840.10008.5.1.4.1.1.3.1",
+                    "Ultrasound Multi-frame Image Storage",
+                ),  # US -> Ultrasound Multi-frame
             }
 
             original_sopclass = getattr(datasets[0], "SOPClassUID", None)
@@ -1186,7 +1220,9 @@ def convert_single_frame_dicom_series_to_multiframe(
                 else:
                     # If missing, use default (0,0,frame_idx * spacing)
                     # This shouldn't happen for valid CT series, but ensures MPR compatibility
-                    default_spacing = float(output_ds.SpacingBetweenSlices) if hasattr(output_ds, 'SpacingBetweenSlices') else 1.0
+                    default_spacing = (
+                        float(output_ds.SpacingBetweenSlices) if hasattr(output_ds, "SpacingBetweenSlices") else 1.0
+                    )
                     plane_pos_item.ImagePositionPatient = [0.0, 0.0, frame_idx * default_spacing]
                     logger.warning(f"    Frame {frame_idx} missing ImagePositionPatient, using default")
                 frame_item.PlanePositionSequence = Sequence([plane_pos_item])

tests/unit/datastore/test_convert_htj2k.py

@@ -10,6 +10,7 @@
 # limitations under the License.
 
 import os
+import shutil
 import tempfile
 import unittest
 from pathlib import Path
@@ -786,7 +787,9 @@ def test_transcode_dicom_to_htj2k_multiframe_metadata(self):
             first_original = original_datasets[0]
 
             # Check ImagePositionPatient is NOT there at top level DICOM file
-            self.assertFalse(hasattr(ds_multiframe, "ImagePositionPatient"), "Should not have ImagePositionPatient at top level")
+            self.assertFalse(
+                hasattr(ds_multiframe, "ImagePositionPatient"), "Should not have ImagePositionPatient at top level"
+            )
 
             # Check PixelSpacing
             self.assertTrue(hasattr(ds_multiframe, "PixelSpacing"), "Should have PixelSpacing")
@@ -812,31 +815,31 @@ def test_transcode_dicom_to_htj2k_multiframe_metadata(self):
             # Check SOPClassUID conversion to Enhanced/Multi-frame
             self.assertTrue(hasattr(ds_multiframe, "SOPClassUID"), "Should have SOPClassUID")
             self.assertTrue(hasattr(first_original, "SOPClassUID"), "Original should have SOPClassUID")
-            
+
             # Map of single-frame to enhanced/multi-frame SOPClassUIDs
             sopclass_map = {
-                "1.2.840.10008.5.1.4.1.1.2": "1.2.840.10008.5.1.4.1.1.2.1",     # CT -> Enhanced CT
-                "1.2.840.10008.5.1.4.1.1.4": "1.2.840.10008.5.1.4.1.1.4.1",     # MR -> Enhanced MR
-                "1.2.840.10008.5.1.4.1.1.6.1": "1.2.840.10008.5.1.4.1.1.3.1",   # US -> Ultrasound Multi-frame
+                "1.2.840.10008.5.1.4.1.1.2": "1.2.840.10008.5.1.4.1.1.2.1",  # CT -> Enhanced CT
+                "1.2.840.10008.5.1.4.1.1.4": "1.2.840.10008.5.1.4.1.1.4.1",  # MR -> Enhanced MR
+                "1.2.840.10008.5.1.4.1.1.6.1": "1.2.840.10008.5.1.4.1.1.3.1",  # US -> Ultrasound Multi-frame
             }
-            
+
             original_sopclass = str(first_original.SOPClassUID)
             multiframe_sopclass = str(ds_multiframe.SOPClassUID)
-            
+
             if original_sopclass in sopclass_map:
                 expected_sopclass = sopclass_map[original_sopclass]
                 self.assertEqual(
                     multiframe_sopclass,
                     expected_sopclass,
-                    f"SOPClassUID should be converted from {original_sopclass} to {expected_sopclass}"
+                    f"SOPClassUID should be converted from {original_sopclass} to {expected_sopclass}",
                 )
                 print(f"✓ SOPClassUID converted: {original_sopclass} -> {multiframe_sopclass}")
             else:
                 # If not in map, should remain unchanged
                 self.assertEqual(
                     multiframe_sopclass,
                     original_sopclass,
-                    "SOPClassUID should remain unchanged if not in conversion map"
+                    "SOPClassUID should remain unchanged if not in conversion map",
                 )
                 print(f"✓ SOPClassUID unchanged: {multiframe_sopclass}")
 
@@ -1974,6 +1977,139 @@ def collate_paths(batch):
             shutil.rmtree(input_dir, ignore_errors=True)
             shutil.rmtree(output_dir, ignore_errors=True)
 
+    def test_convert_multiframe_handles_missing_pixeldata(self):
+        """Test that convert_single_frame_dicom_series_to_multiframe handles datasets without PixelData."""
+        if not HAS_NVIMGCODEC:
+            self.skipTest(
+                "nvimgcodec not available. Install nvidia-nvimgcodec-cu{XX} matching your CUDA version (e.g., nvidia-nvimgcodec-cu13 for CUDA 13.x)"
+            )
+
+        # Create temporary directory with mixed DICOM files
+        input_dir = tempfile.mkdtemp(prefix="test_missing_pixeldata_")
+        output_dir = tempfile.mkdtemp(prefix="test_missing_pixeldata_output_")
+
+        try:
+            # Create a series with some files having PixelData and some without
+            study_uid = pydicom.uid.generate_uid()
+            series_uid = pydicom.uid.generate_uid()
+
+            print(f"\nCreating test series with mixed PixelData presence...")
+
+            # Create 3 valid DICOM files with PixelData
+            valid_files = []
+            for i in range(3):
+                ds = pydicom.Dataset()
+                ds.StudyInstanceUID = study_uid
+                ds.SeriesInstanceUID = series_uid
+                ds.SOPInstanceUID = pydicom.uid.generate_uid()
+                ds.SOPClassUID = "1.2.840.10008.5.1.4.1.1.2"  # CT Image Storage
+                ds.InstanceNumber = i + 1
+                ds.Modality = "CT"
+                ds.PatientName = "Test^Patient"
+                ds.PatientID = "12345"
+
+                # Add spatial metadata
+                ds.ImagePositionPatient = [0.0, 0.0, float(i * 2.5)]
+                ds.ImageOrientationPatient = [1.0, 0.0, 0.0, 0.0, 1.0, 0.0]
+                ds.PixelSpacing = [0.5, 0.5]
+                ds.SliceThickness = 2.5
+
+                # Add image data
+                ds.Rows = 64
+                ds.Columns = 64
+                ds.SamplesPerPixel = 1
+                ds.PhotometricInterpretation = "MONOCHROME2"
+                ds.BitsAllocated = 16
+                ds.BitsStored = 16
+                ds.HighBit = 15
+                ds.PixelRepresentation = 0
+
+                # Create pixel data
+                pixel_array = np.random.randint(0, 1000, (64, 64), dtype=np.uint16)
+                ds.PixelData = pixel_array.tobytes()
+
+                # Save file with proper file meta
+                ds.file_meta = pydicom.dataset.FileMetaDataset()
+                ds.file_meta.FileMetaInformationVersion = b"\x00\x01"
+                ds.file_meta.TransferSyntaxUID = pydicom.uid.ExplicitVRLittleEndian
+                ds.file_meta.MediaStorageSOPClassUID = ds.SOPClassUID
+                ds.file_meta.MediaStorageSOPInstanceUID = ds.SOPInstanceUID
+                ds.file_meta.ImplementationClassUID = pydicom.uid.PYDICOM_IMPLEMENTATION_UID
+
+                filepath = os.path.join(input_dir, f"valid_{i:03d}.dcm")
+                # Use save_as which properly writes DICOM Part 10 format with preamble
+                ds.save_as(filepath, enforce_file_format=True)
+                valid_files.append(filepath)
+                print(f"  Created valid file: {os.path.basename(filepath)}")
+
+            # Create 2 DICOM files WITHOUT PixelData (like SR or metadata-only)
+            for i in range(2):
+                ds = pydicom.Dataset()
+                ds.StudyInstanceUID = study_uid
+                ds.SeriesInstanceUID = series_uid
+                ds.SOPInstanceUID = pydicom.uid.generate_uid()
+                ds.SOPClassUID = "1.2.840.10008.5.1.4.1.1.2"  # CT Image Storage
+                ds.InstanceNumber = i + 10
+                ds.Modality = "CT"
+                ds.PatientName = "Test^Patient"
+                ds.PatientID = "12345"
+
+                # Add spatial metadata but NO PixelData
+                ds.ImagePositionPatient = [0.0, 0.0, float((i + 10) * 2.5)]
+                ds.ImageOrientationPatient = [1.0, 0.0, 0.0, 0.0, 1.0, 0.0]
+
+                # Save file with proper file meta
+                ds.file_meta = pydicom.dataset.FileMetaDataset()
+                ds.file_meta.FileMetaInformationVersion = b"\x00\x01"
+                ds.file_meta.TransferSyntaxUID = pydicom.uid.ExplicitVRLittleEndian
+                ds.file_meta.MediaStorageSOPClassUID = ds.SOPClassUID
+                ds.file_meta.MediaStorageSOPInstanceUID = ds.SOPInstanceUID
+                ds.file_meta.ImplementationClassUID = pydicom.uid.PYDICOM_IMPLEMENTATION_UID
+
+                filepath = os.path.join(input_dir, f"no_pixel_{i:03d}.dcm")
+                # Use save_as which properly writes DICOM Part 10 format with preamble
+                ds.save_as(filepath, enforce_file_format=True)
+                print(f"  Created file without PixelData: {os.path.basename(filepath)}")
+
+            print(f"✓ Created {len(valid_files)} valid files and 2 files without PixelData")
+
+            # Convert to multiframe - should skip files without PixelData
+            result_dir = convert_single_frame_dicom_series_to_multiframe(
+                input_dir=input_dir,
+                output_dir=output_dir,
+                convert_to_htj2k=True,
+            )
+
+            # Verify multiframe file was created
+            multiframe_files = list(Path(result_dir).rglob("*.dcm"))
+            self.assertEqual(len(multiframe_files), 1, "Should create one multiframe file")
+            print(f"✓ Created multiframe file: {multiframe_files[0]}")
+
+            # Load and verify the multiframe file
+            ds_multiframe = pydicom.dcmread(str(multiframe_files[0]))
+
+            # Should have 3 frames (only the valid files)
+            self.assertTrue(hasattr(ds_multiframe, "NumberOfFrames"), "Should have NumberOfFrames")
+            num_frames = int(ds_multiframe.NumberOfFrames)
+            self.assertEqual(num_frames, 3, "Should have 3 frames (files without PixelData excluded)")
+            print(f"✓ NumberOfFrames: {num_frames} (correctly excluded files without PixelData)")
+
+            # Verify PerFrameFunctionalGroupsSequence has correct number of items
+            self.assertTrue(
+                hasattr(ds_multiframe, "PerFrameFunctionalGroupsSequence"),
+                "Should have PerFrameFunctionalGroupsSequence",
+            )
+            per_frame_seq = ds_multiframe.PerFrameFunctionalGroupsSequence
+            self.assertEqual(len(per_frame_seq), 3, "Should have 3 per-frame items")
+            print(f"✓ PerFrameFunctionalGroupsSequence has {len(per_frame_seq)} items")
+
+            print(f"✓ Test passed: Files without PixelData were correctly skipped")
+
+        finally:
+            # Clean up
+            shutil.rmtree(input_dir, ignore_errors=True)
+            shutil.rmtree(output_dir, ignore_errors=True)
+
 
 if __name__ == "__main__":
     unittest.main()