Contributing Equipment Sequence for DICOM SEG Writer

[bluna301]

Hi all - I have been investigating how MONAI Deploy App SDK DICOM output writers record AI algorithm information in the DICOM tags. My team is hoping to somewhat standardize how this information is written in the DICOM tags for several output types (DICOM SEG, SR, etc.) so that we can easily keep track of and query for this information.

For the SR writer operator and the Encapsulated PDF writer operator, the AI algorithm information is written by the write_common_modules method from dicom_utils under the Contributing Equipment Sequence (0018,A001) nesting using the passed in ModelInfo:

class ModelInfo(object):
    """Class encapsulating AI model information, according to IHE AI Results (AIR) Rev 1.1.

    The attributes of the class will be used to populate the Contributing Equipment Sequence in the DICOM IOD
    per IHE AIR Rev 1.1, Section 6.5.3.1 General Result Encoding Requirements, as the following,

    The Creator shall describe each algorithm that was used to generate the results in the
    Contributing Equipment Sequence (0018,A001). Multiple items may be included. The Creator
    shall encode the following details in the Contributing Equipment Sequence,
        - Purpose of Reference Code Sequence (0040,A170) shall be (Newcode1, 99IHE, 1630 "Processing Algorithm")
        - Manufacturer (0008,0070)
        - Manufacturer's Model Name (0008,1090)
        - Software Versions (0018,1020)
        - Device UID (0018,1002)

    Each time an AI Model is modified, for example by training, it would be appropriate to update
    the Device UID.
    """

    def __init__(self, creator: str = "", name: str = "", version: str = "", uid: str = ""):
        self.creator = creator if isinstance(creator, str) else ""
        self.name = name if isinstance(name, str) else ""
        self.version = version if isinstance(version, str) else ""
        self.uid = uid if isinstance(uid, str) else ""

Additionally, EquipmentInfo will be used to write some un-nested tags; as per the source code below and numerous MONAI Deploy App SDK example apps, this information is seemingly designed to reference the version of MONAI Deploy App SDK used in the pipeline:

class EquipmentInfo(object):
    """Class encapsulating attributes required for DICOM Equipment Module."""

    def __init__(
        self,
        manufacturer: str = "MONAI Deploy",
        manufacturer_model: str = "MONAI Deploy App SDK",
        series_number: str = "0000",
        software_version_number: str = "",
    ):
        self.manufacturer = manufacturer if isinstance(manufacturer, str) else ""
        self.manufacturer_model = manufacturer_model if isinstance(manufacturer_model, str) else ""
        self.series_number = series_number if isinstance(series_number, str) else ""
        if software_version_number:
            self.software_version_number = str(software_version_number)[0:15]
        else:
            try:
                version_str = get_sdk_semver()  # SDK Version
            except Exception:
                version_str = ""  # Fall back to the initial version
            self.software_version_number = version_str[0:15]

For the DICOM SEG writer:

• The Contributing Equipment Sequence (0018,A001) nesting is not present
• Manufacturer and ManufacturerModelName are hardcoded; SoftwareVersions determined by App SDK version present
• AI algorithm information is written under the Segmentation Algorithm Identification Sequence (0062,0007) nesting:

seg = hd.seg.Segmentation(
            source_images=dicom_dataset_list,
            pixel_array=image,
            segmentation_type=hd.seg.SegmentationTypeValues.BINARY,
            segment_descriptions=self._seg_descs,
            series_instance_uid=hd.UID(),
            series_number=random_with_n_digits(4),
            sop_instance_uid=seg_sop_instance_uid,
            instance_number=1,
            manufacturer="The MONAI Consortium",
            manufacturer_model_name="MONAI Deploy App SDK",
            software_versions=version_str,
            device_serial_number="0000",
            omit_empty_frames=self._omit_empty_frames,
        )

self._algorithm_identification = hd.AlgorithmIdentificationSequence(
            name=algorithm_name,
            family=algorithm_family,
            version=algorithm_version,
        )

Both approaches result in very similar information being present in the DICOM tags, albeit in different locations. The DeviceUID DICOM tag is not as easily writable for the DICOM SEG writer, although this tag can be passed as a parameter via custom_tags.

I have two main questions:

• In MAP pipelines, should the MONAI Deploy App SDK information always occupy the un-nested Manufacturer and Software Versions tags? I am curious why this is hardcoded for the DICOM SEG writer, but included as input parameters for the SR and PDF writers (although it does fallback to App SDK values if EquipmentInfo is not provided).
• Is there any appetite for including AI algorithm information under the Contributing Equipment Sequence (0018,A001) nesting for DICOM SEGs? This would help to standardize AI algorithm information in the DICOM tags for all AI outputs. A possible fix would be to update the SEG writer to take in ModelInfo and EquipmentInfo inputs just like the other output writers; we would obviously still want to keep the Segmentation Algorithm Identification Sequence (0062,0007) nesting for the DICOM SEG. To me, it is a bit ambiguous in the IHE Radiology AI Results guide whether DICOM SEGs should or should not have the Contributing Equipment Sequence nesting present.

[MMelQin]

We briefly discussed in the working group meeting, and here is some info for all interested viewers.
Initially the DICOM writers were all created in the App SDK itself, mostly directly using PyDicom. The key metadata encapsulation mostly adhere to IHE AI Results guidance, as mentioned in the inline doc. The whole MONAI ecosystem is about AI based medical image processing, and more, so it makes sense.

Later on, High Dicom package was introduced to replace App SDK's own Seg Writer, for highdicom's maturity and adoption/preference of App SDK contributors. I'd think highdicom is of more general use, hence not necessarily have metadata assignments per IHE AIR. For use of use and consistency, the App SDK Seg Writer operator then encapsulate highdicom API with quite a number of hardcode argument values.

To provide more flexibility in the App SDK, we can

• add optional arguments to the Dicom Seg Writer operator
• enhance the custom tags to support (nested) sequences, and still have the Seg operator to update the Dicom dataset after it has been written by highdicom
• for immediate use without waiting for the updates being released in the next version of the App SDK, a custom Seg Writer operator can be created by reusing much of the code.

If still not completely satisfactory, then contribution to highdicom itself can be considered.

[bluna301]

Initial edits to DICOMSegmentationWriterOperator proposed.