resolve merge conflicts

Author: CPBridge

data/test_files/sm_image_jpegls.dcm

@@ -10,6 +10,7 @@ readme = "README.md"
 requires-python = ">=3.10"
 authors = [
     { name = "Markus D. Herrmann" },
+    { name = "Christopher P. Bridge" },
 ]
 maintainers = [
     { name = "Markus D. Herrmann" },

data/test_files/sm_image_jpegls_nobot.dcm

@@ -4076,12 +4076,6 @@ def _generate_cross_sectional_descriptors(
                 relationship_type=RelationshipTypeValues.HAS_ACQ_CONTEXT,
                 unit=codes.UCUM.Millimeter
             ),
-            NumContentItem(
-                name=codes.DCM.SpacingBetweenSlices,
-                value=dataset.SpacingBetweenSlices,
-                relationship_type=RelationshipTypeValues.HAS_ACQ_CONTEXT,
-                unit=codes.UCUM.Millimeter
-            ),
             NumContentItem(
                 name=codes.DCM.SliceThickness,
                 value=dataset.SliceThickness,
@@ -4167,6 +4161,16 @@ def _generate_cross_sectional_descriptors(
                 )
             )
         ]
+        if hasattr(dataset, 'SpacingBetweenSlices'):
+            descriptors.append(
+                NumContentItem(
+                    name=codes.DCM.SpacingBetweenSlices,
+                    value=dataset.SpacingBetweenSlices,
+                    relationship_type=RelationshipTypeValues.HAS_ACQ_CONTEXT,
+                    unit=codes.UCUM.Millimeter
+                ),
+            )
+
         return descriptors
 
     def _is_cross_sectional(self, ds: Dataset) -> bool:

pyproject.toml

@@ -90,10 +90,17 @@ def search_tree(
         matched_content_items = []
         for content_item in node.ContentSequence:
             name_code = content_item.ConceptNameCodeSequence[0]
+            if hasattr(name_code, "CodeValue"):
+                code_value = name_code.CodeValue
+            elif hasattr(name_code, "LongCodeValue"):
+                code_value = name_code.LongCodeValue
+            else:
+                code_value = name_code.URNCodeValue
+
             item = ContentItem(
                 value_type=content_item.ValueType,
                 name=CodedConcept(
-                    value=name_code.CodeValue,
+                    value=code_value,
                     scheme_designator=name_code.CodingSchemeDesignator,
                     meaning=name_code.CodeMeaning
                 ),

src/highdicom/sr/templates.py

@@ -76,6 +76,26 @@ def test_read_multi_frame_sm_image_native(self):
                 )
                 np.testing.assert_array_equal(frame, pixel_array[i, ...])
 
+    def test_read_multi_frame_sm_image_jpegls(self):
+        filename = str(self._test_dir.joinpath('sm_image_jpegls.dcm'))
+        dataset = dcmread(filename)
+        pixel_array = dataset.pixel_array
+        with ImageFileReader(filename) as reader:
+            assert reader.number_of_frames == 25
+            indices = list(range(reader.number_of_frames))
+            shuffle(indices)
+            for i in indices:
+                frame = reader.read_frame(i, correct_color=False)
+                assert isinstance(frame, np.ndarray)
+                assert frame.ndim == 3
+                assert frame.dtype == np.uint8
+                assert frame.shape == (
+                    reader.metadata.Rows,
+                    reader.metadata.Columns,
+                    reader.metadata.SamplesPerPixel,
+                )
+                np.testing.assert_array_equal(frame, pixel_array[i, ...])
+
     def test_read_multi_frame_sm_image_numbers_native(self):
         filename = str(self._test_dir.joinpath('sm_image_numbers.dcm'))
         dataset = dcmread(filename)
@@ -216,6 +236,90 @@ def test_read_single_frame_ct_image_dicom_file_like_opened(self):
             )
             np.testing.assert_array_equal(frame, pixel_array)
 
+    def test_read_single_frame_sm_image_jpegls_dicom_bytes_io(self):
+        filename = str(self._test_dir.joinpath("sm_image_jpegls.dcm"))
+        dcm = DicomBytesIO(open(filename, "rb").read())
+
+        dataset = dcmread(filename)
+        pixel_array = dataset.pixel_array
+        with ImageFileReader(dcm) as reader:
+            assert reader.number_of_frames == 25
+            for fno in range(reader.number_of_frames):
+                frame = reader.read_frame(fno)
+                assert isinstance(frame, np.ndarray)
+                assert frame.ndim == 3
+                assert frame.dtype == np.uint8
+                assert frame.shape == (
+                    reader.metadata.Rows,
+                    reader.metadata.Columns,
+                    3,
+                )
+                np.testing.assert_array_equal(frame, pixel_array[fno])
+
+    def test_read_single_frame_sm_image_jpegls_nobot_dicom_bytes_io(self):
+        filename = str(self._test_dir.joinpath("sm_image_jpegls_nobot.dcm"))
+        dcm = DicomBytesIO(open(filename, "rb").read())
+
+        dataset = dcmread(filename)
+        pixel_array = dataset.pixel_array
+        with ImageFileReader(dcm) as reader:
+            assert reader.number_of_frames == 25
+            for fno in range(reader.number_of_frames):
+                frame = reader.read_frame(fno)
+                assert isinstance(frame, np.ndarray)
+                assert frame.ndim == 3
+                assert frame.dtype == np.uint8
+                assert frame.shape == (
+                    reader.metadata.Rows,
+                    reader.metadata.Columns,
+                    3,
+                )
+                np.testing.assert_array_equal(frame, pixel_array[fno])
+
+    def test_read_single_frame_sm_image_jpegls_dicom_file_like_opened(self):
+        # Test reading frames from an opened DicomFileLike file
+        filename = self._test_dir.joinpath("sm_image_jpegls.dcm")
+        dcm = DicomFileLike(filename.open("rb"))
+
+        dataset = dcmread(filename)
+        pixel_array = dataset.pixel_array
+        with ImageFileReader(dcm) as reader:
+            assert reader.number_of_frames == 25
+            for fno in range(reader.number_of_frames):
+                frame = reader.read_frame(fno)
+                assert isinstance(frame, np.ndarray)
+                assert frame.ndim == 3
+                assert frame.dtype == np.uint8
+                assert frame.shape == (
+                    reader.metadata.Rows,
+                    reader.metadata.Columns,
+                    3,
+                )
+                np.testing.assert_array_equal(frame, pixel_array[fno])
+
+    def test_read_single_frame_sm_image_jpegls_nobot_dicom_file_like_opened(
+        self
+    ):
+        # Test reading frames from an opened DicomFileLike file
+        filename = self._test_dir.joinpath("sm_image_jpegls_nobot.dcm")
+        dcm = DicomFileLike(filename.open("rb"))
+
+        dataset = dcmread(filename)
+        pixel_array = dataset.pixel_array
+        with ImageFileReader(dcm) as reader:
+            assert reader.number_of_frames == 25
+            for fno in range(reader.number_of_frames):
+                frame = reader.read_frame(fno)
+                assert isinstance(frame, np.ndarray)
+                assert frame.ndim == 3
+                assert frame.dtype == np.uint8
+                assert frame.shape == (
+                    reader.metadata.Rows,
+                    reader.metadata.Columns,
+                    3,
+                )
+                np.testing.assert_array_equal(frame, pixel_array[fno])
+
     def test_read_rle_no_bot(self):
         # This image is RLE compressed but has no BOT, requiring searching
         # through the pixel data for delimiter tags

src/highdicom/sr/utils.py

@@ -4560,6 +4560,38 @@ def test_find_content_items(self):
         items = find_content_items(self._sr_document)
         assert len(items) == 8
 
+    def test_find_content_items_with_URN_code_value(self):
+        file_path = Path(__file__)
+        data_dir = file_path.parent.parent.joinpath('data')
+        my_sr_document = dcmread(
+            str(data_dir.joinpath('test_files', 'sr_document.dcm'))
+        )
+        content_sequence = my_sr_document.ContentSequence[0]
+        concept_name_code_sequence = content_sequence.ConceptNameCodeSequence[0]
+        # remove existing code value
+        del concept_name_code_sequence.CodeValue
+        # add URN Code Value
+        URN_code_value = "http://example.com/my_urn_value"
+        concept_name_code_sequence.URNCodeValue = URN_code_value
+        items = find_content_items(my_sr_document)
+        assert len(items) == 8
+
+    def test_find_content_items_with_long_code_value(self):
+        file_path = Path(__file__)
+        data_dir = file_path.parent.parent.joinpath('data')
+        my_sr_document = dcmread(
+            str(data_dir.joinpath('test_files', 'sr_document.dcm'))
+        )
+        content_sequence = my_sr_document.ContentSequence[0]
+        concept_name_code_sequence = content_sequence.ConceptNameCodeSequence[0]
+        # remove existing code value
+        del concept_name_code_sequence.CodeValue
+        # add Long Code Value
+        long_code_value = "Test_A_Long_Code_Value"
+        concept_name_code_sequence.LongCodeValue = long_code_value
+        items = find_content_items(my_sr_document)
+        assert len(items) == 8
+
     def test_find_content_items_filtered_by_name(self):
         items = find_content_items(
             self._sr_document,
@@ -5471,79 +5503,101 @@ def test_ct_construction(self):
             image=self._ref_ct_dataset,
         )
         assert len(group) == 17
-        assert isinstance(group[0], CodeContentItem)
-        assert group[0].name == codes.DCM.Modality
-        assert group[0].value == codes.cid29.ComputedTomography
-        assert isinstance(group[1], UIDRefContentItem)
-        assert group[1].name == codes.DCM.FrameOfReferenceUID
-        assert group[1].value == self._ref_ct_dataset.FrameOfReferenceUID
-        assert isinstance(group[2], NumContentItem)
-        assert group[2].name == codes.DCM.PixelDataRows
-        assert group[2].value == self._ref_ct_dataset.Rows
-        assert isinstance(group[3], NumContentItem)
-        assert group[3].name == codes.DCM.PixelDataColumns
-        assert group[3].value == self._ref_ct_dataset.Columns
-        assert isinstance(group[4], NumContentItem)
-        assert group[4].name == codes.DCM.HorizontalPixelSpacing
-        assert group[4].value == self._ref_ct_dataset.PixelSpacing[0]
-        value_item = group[4].MeasuredValueSequence[0]
+
+        # Check Modality
+        modality = group.find(name=codes.DCM.Modality)[0]
+        assert isinstance(modality, CodeContentItem)
+        assert modality.value == codes.cid29.ComputedTomography
+
+        # Check Frame of Reference UID
+        frame_ref = group.find(name=codes.DCM.FrameOfReferenceUID)[0]
+        assert isinstance(frame_ref, UIDRefContentItem)
+        assert frame_ref.value == self._ref_ct_dataset.FrameOfReferenceUID
+
+        # Check Pixel Data Rows
+        rows = group.find(name=codes.DCM.PixelDataRows)[0]
+        assert isinstance(rows, NumContentItem)
+        assert rows.value == self._ref_ct_dataset.Rows
+
+        # Check Pixel Data Columns
+        columns = group.find(name=codes.DCM.PixelDataColumns)[0]
+        assert isinstance(columns, NumContentItem)
+        assert columns.value == self._ref_ct_dataset.Columns
+
+        # Check Horizontal Pixel Spacing
+        h_spacing = group.find(name=codes.DCM.HorizontalPixelSpacing)[0]
+        assert isinstance(h_spacing, NumContentItem)
+        assert h_spacing.value == self._ref_ct_dataset.PixelSpacing[0]
+        value_item = h_spacing.MeasuredValueSequence[0]
         unit_code_item = value_item.MeasurementUnitsCodeSequence[0]
         assert unit_code_item.CodeValue == 'mm'
         assert unit_code_item.CodeMeaning == 'mm'
         assert unit_code_item.CodingSchemeDesignator == 'UCUM'
-        assert isinstance(group[5], NumContentItem)
-        assert group[5].name == codes.DCM.VerticalPixelSpacing
-        assert group[5].value == self._ref_ct_dataset.PixelSpacing[1]
-        assert isinstance(group[6], NumContentItem)
-        assert group[6].name == codes.DCM.SpacingBetweenSlices
-        assert group[6].value == self._ref_ct_dataset.SpacingBetweenSlices
-        value_item = group[6].MeasuredValueSequence[0]
+
+        # Check Vertical Pixel Spacing
+        v_spacing = group.find(name=codes.DCM.VerticalPixelSpacing)[0]
+        assert isinstance(v_spacing, NumContentItem)
+        assert v_spacing.value == self._ref_ct_dataset.PixelSpacing[1]
+
+        # Check Spacing Between Slices
+        slice_spacing = group.find(name=codes.DCM.SpacingBetweenSlices)[0]
+        assert isinstance(slice_spacing, NumContentItem)
+        assert slice_spacing.value == self._ref_ct_dataset.SpacingBetweenSlices
+        value_item = slice_spacing.MeasuredValueSequence[0]
         unit_code_item = value_item.MeasurementUnitsCodeSequence[0]
         assert unit_code_item.CodeValue == 'mm'
         assert unit_code_item.CodeMeaning == 'mm'
         assert unit_code_item.CodingSchemeDesignator == 'UCUM'
-        assert isinstance(group[7], NumContentItem)
-        assert group[7].name == codes.DCM.SliceThickness
-        assert group[7].value == self._ref_ct_dataset.SliceThickness
-        assert isinstance(group[8], NumContentItem)
-        assert group[8].name == codes.DCM.ImagePositionPatientX
-        assert group[8].value == self._ref_ct_dataset.ImagePositionPatient[0]
-        assert isinstance(group[9], NumContentItem)
-        assert group[9].name == codes.DCM.ImagePositionPatientY
-        assert group[9].value == self._ref_ct_dataset.ImagePositionPatient[1]
-        assert isinstance(group[10], NumContentItem)
-        assert group[10].name == codes.DCM.ImagePositionPatientZ
-        assert group[10].value == self._ref_ct_dataset.ImagePositionPatient[2]
-        assert isinstance(group[11], NumContentItem)
-        assert group[11].name == codes.DCM.ImageOrientationPatientRowX
-        assert group[11].value == \
-               self._ref_ct_dataset.ImageOrientationPatient[0]
-        value_item = group[11].MeasuredValueSequence[0]
+
+        # Check Slice Thickness
+        thickness = group.find(name=codes.DCM.SliceThickness)[0]
+        assert isinstance(thickness, NumContentItem)
+        assert thickness.value == self._ref_ct_dataset.SliceThickness
+
+        # Check Image Position Patient
+        pos_x = group.find(name=codes.DCM.ImagePositionPatientX)[0]
+        assert isinstance(pos_x, NumContentItem)
+        assert pos_x.value == self._ref_ct_dataset.ImagePositionPatient[0]
+
+        pos_y = group.find(name=codes.DCM.ImagePositionPatientY)[0]
+        assert isinstance(pos_y, NumContentItem)
+        assert pos_y.value == self._ref_ct_dataset.ImagePositionPatient[1]
+
+        pos_z = group.find(name=codes.DCM.ImagePositionPatientZ)[0]
+        assert isinstance(pos_z, NumContentItem)
+        assert pos_z.value == self._ref_ct_dataset.ImagePositionPatient[2]
+
+        # Check Image Orientation Patient Row
+        row_x = group.find(name=codes.DCM.ImageOrientationPatientRowX)[0]
+        assert isinstance(row_x, NumContentItem)
+        assert row_x.value == self._ref_ct_dataset.ImageOrientationPatient[0]
+        value_item = row_x.MeasuredValueSequence[0]
         unit_code_item = value_item.MeasurementUnitsCodeSequence[0]
         assert unit_code_item.CodeValue == '{-1:1}'
         assert unit_code_item.CodeMeaning == '{-1:1}'
         assert unit_code_item.CodingSchemeDesignator == 'UCUM'
-        assert isinstance(group[12], NumContentItem)
-        assert group[12].name == codes.DCM.ImageOrientationPatientRowY
-        assert group[12].value == \
-            self._ref_ct_dataset.ImageOrientationPatient[1]
-        assert isinstance(group[13], NumContentItem)
-        assert group[13].name == codes.DCM.ImageOrientationPatientRowZ
-        assert group[13].value == \
-               self._ref_ct_dataset.ImageOrientationPatient[2]
-        assert isinstance(group[14], NumContentItem)
-        assert group[14].name == codes.DCM.ImageOrientationPatientColumnX
-        assert group[14].value == \
-               self._ref_ct_dataset.ImageOrientationPatient[3]
-        assert isinstance(group[15], NumContentItem)
-        assert group[15].name == codes.DCM.ImageOrientationPatientColumnY
-        assert group[15].value == \
-               self._ref_ct_dataset.ImageOrientationPatient[4]
-        assert isinstance(group[16], NumContentItem)
-        assert group[16].name == codes.DCM.ImageOrientationPatientColumnZ
-        assert group[16].value == \
-               self._ref_ct_dataset.ImageOrientationPatient[5]
-        value_item = group[16].MeasuredValueSequence[0]
+
+        row_y = group.find(name=codes.DCM.ImageOrientationPatientRowY)[0]
+        assert isinstance(row_y, NumContentItem)
+        assert row_y.value == self._ref_ct_dataset.ImageOrientationPatient[1]
+
+        row_z = group.find(name=codes.DCM.ImageOrientationPatientRowZ)[0]
+        assert isinstance(row_z, NumContentItem)
+        assert row_z.value == self._ref_ct_dataset.ImageOrientationPatient[2]
+
+        # Check Image Orientation Patient Column
+        col_x = group.find(name=codes.DCM.ImageOrientationPatientColumnX)[0]
+        assert isinstance(col_x, NumContentItem)
+        assert col_x.value == self._ref_ct_dataset.ImageOrientationPatient[3]
+
+        col_y = group.find(name=codes.DCM.ImageOrientationPatientColumnY)[0]
+        assert isinstance(col_y, NumContentItem)
+        assert col_y.value == self._ref_ct_dataset.ImageOrientationPatient[4]
+
+        col_z = group.find(name=codes.DCM.ImageOrientationPatientColumnZ)[0]
+        assert isinstance(col_z, NumContentItem)
+        assert col_z.value == self._ref_ct_dataset.ImageOrientationPatient[5]
+        value_item = col_z.MeasuredValueSequence[0]
         unit_code_item = value_item.MeasurementUnitsCodeSequence[0]
         assert unit_code_item.CodeValue == '{-1:1}'
         assert unit_code_item.CodeMeaning == '{-1:1}'
@@ -5643,6 +5697,11 @@ def test_dx_construction(self):
         assert group[8].name == codes.DCM.ContentTime
         assert group[8].value == content_time
 
+    def test_optional_spacing_between_slices(self):
+        del self._ref_ct_dataset.SpacingBetweenSlices
+        group = ImageLibraryEntryDescriptors(image=self._ref_ct_dataset)
+        assert not group.find(name=codes.DCM.SpacingBetweenSlices)
+
 
 class TestImageLibrary(unittest.TestCase):