Set correct SOPClassUID for multi-frame files

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

Author: jantonguirao

monailabel/datastore/utils/convert_htj2k.py

@@ -1046,10 +1046,16 @@ def convert_single_frame_dicom_series_to_multiframe(
                     # Uncompressed numpy arrays
                     encoded_frames_bytes = None
 
+            # 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]
+            
             # 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...")
-            output_ds = datasets[0].copy()  # Start from first dataset
+            output_ds = datasets[0].copy()  # shallow copy
 
             # CRITICAL: Set SOP Instance UID to match the SeriesInstanceUID (which will be the filename)
             # This ensures the file's internal SOP Instance UID matches its filename
@@ -1110,10 +1116,20 @@ def convert_single_frame_dicom_series_to_multiframe(
             if hasattr(output_ds, "ImageOrientationPatient"):
                 delattr(output_ds, "ImageOrientationPatient")
                 logger.info(f"  ✓ Removed top-level ImageOrientationPatient (use SharedFunctionalGroupsSequence only)")
-            
-            # CRITICAL: Set correct SOPClassUID for Enhanced multi-frame CT
-            output_ds.SOPClassUID = "1.2.840.10008.5.1.4.1.1.2.1"  # Enhanced CT Image Storage
-            logger.info(f"  ✓ Set SOPClassUID to Enhanced CT Image Storage")
+            # 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
+            }
+
+            original_sopclass = getattr(datasets[0], "SOPClassUID", None)
+            if original_sopclass and str(original_sopclass) in sopclass_map:
+                new_uid, desc = sopclass_map[str(original_sopclass)]
+                output_ds.SOPClassUID = new_uid
+                logger.info(f"  ✓ Set SOPClassUID to {desc}")
+            else:
+                logger.info(f"  Keeping original SOPClassUID: {original_sopclass}")
 
             # Keep pixel spacing and slice thickness
             if hasattr(datasets[0], "PixelSpacing"):
@@ -1164,8 +1180,9 @@ def convert_single_frame_dicom_series_to_multiframe(
                 # PlanePositionSequence - ImagePositionPatient for this frame
                 # This is MANDATORY for Enhanced CT multi-frame
                 plane_pos_item = DicomDataset()
-                if hasattr(ds_frame, "ImagePositionPatient"):
-                    plane_pos_item.ImagePositionPatient = ds_frame.ImagePositionPatient
+                # Use saved value (before it was deleted from datasets)
+                if original_image_positions[frame_idx] is not None:
+                    plane_pos_item.ImagePositionPatient = original_image_positions[frame_idx]
                 else:
                     # If missing, use default (0,0,frame_idx * spacing)
                     # This shouldn't happen for valid CT series, but ensures MPR compatibility
@@ -1199,8 +1216,9 @@ def convert_single_frame_dicom_series_to_multiframe(
 
             # PlaneOrientationSequence - MANDATORY for Enhanced CT multi-frame
             shared_orient_item = DicomDataset()
-            if hasattr(datasets[0], "ImageOrientationPatient"):
-                shared_orient_item.ImageOrientationPatient = datasets[0].ImageOrientationPatient
+            # Use saved value (before it was deleted from datasets)
+            if original_image_orientation is not None:
+                shared_orient_item.ImageOrientationPatient = original_image_orientation
             else:
                 # If missing, use standard axial orientation
                 # This ensures MPR button is enabled in OHIF
@@ -1260,7 +1278,7 @@ def convert_single_frame_dicom_series_to_multiframe(
 
             # Save as single multi-frame file
             output_file = os.path.join(study_output_dir, f"{series_uid}.dcm")
-            output_ds.save_as(output_file, write_like_original=False)
+            output_ds.save_as(output_file, enforce_file_format=False)
 
             logger.info(f"  ✓ Saved multi-frame file: {output_file}")
             processed_series += 1

tests/unit/datastore/test_convert_htj2k.py

@@ -785,25 +785,8 @@ def test_transcode_dicom_to_htj2k_multiframe_metadata(self):
             # Verify top-level metadata matches first frame
             first_original = original_datasets[0]
 
-            # Check ImagePositionPatient (top-level should match first frame)
-            self.assertTrue(hasattr(ds_multiframe, "ImagePositionPatient"), "Should have ImagePositionPatient")
-            np.testing.assert_array_almost_equal(
-                np.array([float(x) for x in ds_multiframe.ImagePositionPatient]),
-                np.array([float(x) for x in first_original.ImagePositionPatient]),
-                decimal=6,
-                err_msg="Top-level ImagePositionPatient should match first original file",
-            )
-            print(f"✓ ImagePositionPatient matches first frame: {ds_multiframe.ImagePositionPatient}")
-
-            # Check ImageOrientationPatient
-            self.assertTrue(hasattr(ds_multiframe, "ImageOrientationPatient"), "Should have ImageOrientationPatient")
-            np.testing.assert_array_almost_equal(
-                np.array([float(x) for x in ds_multiframe.ImageOrientationPatient]),
-                np.array([float(x) for x in first_original.ImageOrientationPatient]),
-                decimal=6,
-                err_msg="ImageOrientationPatient should match original",
-            )
-            print(f"✓ ImageOrientationPatient matches original: {ds_multiframe.ImageOrientationPatient}")
+            # Check ImagePositionPatient is NOT there at top level DICOM file
+            self.assertFalse(hasattr(ds_multiframe, "ImagePositionPatient"), "Should not have ImagePositionPatient at top level")
 
             # Check PixelSpacing
             self.assertTrue(hasattr(ds_multiframe, "PixelSpacing"), "Should have PixelSpacing")
@@ -826,6 +809,37 @@ def test_transcode_dicom_to_htj2k_multiframe_metadata(self):
                 )
                 print(f"✓ SliceThickness matches original: {ds_multiframe.SliceThickness}")
 
+            # 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
+            }
+            
+            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}"
+                )
+                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"
+                )
+                print(f"✓ SOPClassUID unchanged: {multiframe_sopclass}")
+
             # Check for PerFrameFunctionalGroupsSequence
             self.assertTrue(
                 hasattr(ds_multiframe, "PerFrameFunctionalGroupsSequence"),
@@ -868,30 +882,31 @@ def test_transcode_dicom_to_htj2k_multiframe_metadata(self):
                 except AssertionError as e:
                     mismatches.append(f"Frame {frame_idx}: {e}")
 
-                # Check PlaneOrientationSequence
-                self.assertTrue(
+                # PlaneOrientationSequence should ONLY be in SharedFunctionalGroupsSequence, not per-frame
+                self.assertFalse(
                     hasattr(frame_item, "PlaneOrientationSequence"),
-                    f"Frame {frame_idx} should have PlaneOrientationSequence",
+                    f"Frame {frame_idx} should not have PlaneOrientationSequence",
                 )
-                plane_orient = frame_item.PlaneOrientationSequence[0]
-                self.assertTrue(
-                    hasattr(plane_orient, "ImageOrientationPatient"),
-                    f"Frame {frame_idx} should have ImageOrientationPatient in PlaneOrientationSequence",
-                )
-
-                # Verify ImageOrientationPatient matches original
-                multiframe_iop = np.array([float(x) for x in plane_orient.ImageOrientationPatient])
-                original_iop = np.array([float(x) for x in original_ds.ImageOrientationPatient])
 
-                try:
-                    np.testing.assert_array_almost_equal(
-                        multiframe_iop,
-                        original_iop,
-                        decimal=6,
-                        err_msg=f"Frame {frame_idx} ImageOrientationPatient should match original",
-                    )
-                except AssertionError as e:
-                    mismatches.append(f"Frame {frame_idx}: {e}")
+            # Verify ImageOrientationPatient in SharedFunctionalGroupsSequence matches original
+            shared_fg = ds_multiframe.SharedFunctionalGroupsSequence[0]
+            self.assertTrue(
+                hasattr(shared_fg, "PlaneOrientationSequence"),
+                "SharedFunctionalGroupsSequence should have PlaneOrientationSequence",
+            )
+            plane_orient = shared_fg.PlaneOrientationSequence[0]
+            multiframe_iop = np.array([float(x) for x in plane_orient.ImageOrientationPatient])
+            original_iop = np.array([float(x) for x in original_datasets[0].ImageOrientationPatient])  # Use first frame
+
+            try:
+                np.testing.assert_array_almost_equal(
+                    multiframe_iop,
+                    original_iop,
+                    decimal=6,
+                    err_msg="SharedFunctionalGroupsSequence ImageOrientationPatient should match original",  # Remove frame_idx
+                )
+            except AssertionError as e:
+                mismatches.append(f"Shared orientation: {e}")  # Remove frame_idx reference
 
             # Report any mismatches
             if mismatches: