App SDK updated to be compatible with monai 1.0.0 and its MetaTensor (#360)

* Updated to be compitable with monai 1.0.0 and its MetaTensor

Signed-off-by: M Q <mingmelvinq@nvidia.com>

* Made bundle inference operator compatible with MetaTensor

Signed-off-by: M Q <mingmelvinq@nvidia.com>

* Removed the use of ToTensor from all apps.

Signed-off-by: M Q <mingmelvinq@nvidia.com>

* Fix MyPy complaints

Signed-off-by: M Q <mingmelvinq@nvidia.com>

* Fix isort complaint

Signed-off-by: M Q <mingmelvinq@nvidia.com>

* Use a constant for repeated use of monai.utils str literal; SonarCloud code smell.

Signed-off-by: M Q <mingmelvinq@nvidia.com>

* Updated Seg Writer and Spleen Seg Jupyter notebooks

Signed-off-by: M Q <mingmelvinq@nvidia.com>

* Minor to address comments and checker complaint

Signed-off-by: M Q <mingmelvinq@nvidia.com>

* Updated clara-viz Jupyter notebook and fixed checking complaint

Signed-off-by: M Q <mingmelvinq@nvidia.com>

Signed-off-by: M Q <mingmelvinq@nvidia.com>

Author: MMelQin

examples/apps/ai_livertumor_seg_app/livertumor_seg_operator.py

@@ -27,14 +27,13 @@
     SaveImaged,
     ScaleIntensityRanged,
     Spacingd,
-    ToTensord,
 )
 
 
 @md.input("image", Image, IOType.IN_MEMORY)
 @md.output("seg_image", Image, IOType.IN_MEMORY)
 @md.output("saved_images_folder", DataPath, IOType.DISK)
-@md.env(pip_packages=["monai==0.9.0", "torch>=1.5", "numpy>=1.21", "nibabel"])
+@md.env(pip_packages=["monai>=1.0.0", "torch>=1.5", "numpy>=1.21", "nibabel"])
 class LiverTumorSegOperator(Operator):
     """Performs liver and tumor segmentation using a DL model with an image converted from a DICOM CT series.
 
@@ -121,7 +120,6 @@ def pre_process(self, img_reader, out_dir: str = "./input_images") -> Compose:
                 Spacingd(keys=my_key, pixdim=(1.0, 1.0, 1.0), mode=("bilinear"), align_corners=True),
                 ScaleIntensityRanged(my_key, a_min=-21, a_max=189, b_min=0.0, b_max=1.0, clip=True),
                 CropForegroundd(my_key, source_key=my_key),
-                ToTensord(my_key),
             ]
         )
 

examples/apps/ai_spleen_seg_app/app.py

@@ -81,7 +81,12 @@ def compose(self):
                 algorithm_version="0.1.0",
             )
         ]
-        dicom_seg_writer = DICOMSegmentationWriterOperator(segment_descriptions=segment_descriptions)
+
+        custom_tags = {"SeriesDescription": "AI generated Seg, not for clinical use."}
+
+        dicom_seg_writer = DICOMSegmentationWriterOperator(
+            segment_descriptions=segment_descriptions, custom_tags=custom_tags
+        )
 
         # Create the processing pipeline, by specifying the source and destination operators, and
         # ensuring the output from the former matches the input of the latter, in both name and type.

examples/apps/ai_unetr_seg_app/unetr_seg_operator.py

@@ -28,7 +28,6 @@
     SaveImaged,
     ScaleIntensityRanged,
     Spacingd,
-    ToTensord,
 )
 
 
@@ -114,7 +113,6 @@ def pre_process(self, img_reader, out_dir: str = "./input_images") -> Compose:
                 Orientationd(keys=my_key, axcodes="RAS"),
                 ScaleIntensityRanged(my_key, a_min=-175, a_max=250, b_min=0.0, b_max=1.0, clip=True),
                 CropForegroundd(my_key, source_key=my_key),
-                ToTensord(my_key),
             ]
         )
 

integrations/nuance_pin/app/inference.py

@@ -37,7 +37,6 @@
     ScaleIntensityRanged,
     Spacingd,
     ToDeviced,
-    ToTensord,
 )
 
 sliding_window_inference, _ = optional_import("monai.inferers", name="sliding_window_inference")
@@ -178,9 +177,6 @@ def pre_process(self, img_reader) -> Compose:
                     keys=[image_key, f"{image_key}_meta_dict"],
                     names=[orig_image_key, f"{orig_image_key}_meta_dict"],
                 ),
-                ToTensord(
-                    keys=image_key,
-                ),
                 ToDeviced(keys=image_key, device="cuda"),
                 EnsureChannelFirstd(keys=image_key),
                 Spacingd(keys=image_key, pixdim=(0.703125, 0.703125, 1.25)),

monai/deploy/operators/dicom_seg_writer_operator.py

@@ -9,10 +9,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
+import datetime
+import logging
 from pathlib import Path
 from random import randint
-from typing import TYPE_CHECKING, List, Optional, Sequence, Union
+from typing import TYPE_CHECKING, Dict, List, Optional, Sequence, Union
 
 import numpy as np
 from typeguard import typechecked
@@ -166,10 +167,14 @@ class DICOMSegmentationWriterOperator(Operator):
     SUPPORTED_EXTENSIONS = [".nii", ".nii.gz", ".mhd"]
     # DICOM instance file extension. Case insensitive in string comparison.
     DCM_EXTENSION = ".dcm"
-    # Suffix to add to file name to indicate DICOM Seg dcm file.
-    DICOMSEG_SUFFIX = "-DICOMSEG"
 
-    def __init__(self, segment_descriptions: List[SegmentDescription], *args, **kwargs):
+    def __init__(
+        self,
+        segment_descriptions: List[SegmentDescription],
+        custom_tags: Optional[Dict[str, str]] = None,
+        *args,
+        **kwargs,
+    ):
         super().__init__(*args, **kwargs)
         """Instantiates the DICOM Seg Writer instance with optional list of segment label strings.
 
@@ -185,11 +190,14 @@ def __init__(self, segment_descriptions: List[SegmentDescription], *args, **kwar
         segment label information, including label value, name, description etc.
 
         Args:
-            segment_descriptions: Object encapsulating the description of each segment present in the
-            segmentation.
+            segment_descriptions: List[SegmentDescription]
+                Object encapsulating the description of each segment present in the segmentation.
+            custom_tags: OptonalDict[str, str], optional
+                Dictionary for setting custom DICOM tags using Keywords and str values only
         """
 
         self._seg_descs = [sd.to_segment_description(n) for n, sd in enumerate(segment_descriptions, 1)]
+        self._custom_tags = custom_tags
 
     def compute(self, op_input: InputContext, op_output: OutputContext, context: ExecutionContext):
         """Performs computation for this operator and handles I/O.
@@ -241,25 +249,26 @@ def process_images(
         else:
             raise ValueError("'image' is not an Image object or a supported image file.")
 
-        # The output DICOM Seg instance file name is based on the actual or made-up input image file name.
-        output_filename = "{0}{1}{2}".format(
-            os.path.splitext(os.path.basename(input_path))[0],
-            DICOMSegmentationWriterOperator.DICOMSEG_SUFFIX,
-            DICOMSegmentationWriterOperator.DCM_EXTENSION,
-        )
-        output_path = output_dir / output_filename
         # Pick DICOM Series that was used as input for getting the seg image.
         # For now, first one in the list.
         for study_selected_series in study_selected_series_list:
             if not isinstance(study_selected_series, StudySelectedSeries):
                 raise ValueError("Element in input is not expected type, 'StudySelectedSeries'.")
             selected_series = study_selected_series.selected_series[0]
             dicom_series = selected_series.series
-            self.create_dicom_seg(seg_image_numpy, dicom_series, output_path)
+            self.create_dicom_seg(seg_image_numpy, dicom_series, output_dir)
             break
 
-    def create_dicom_seg(self, image: np.ndarray, dicom_series: DICOMSeries, file_path: Path):
-        file_path.parent.absolute().mkdir(parents=True, exist_ok=True)
+    def create_dicom_seg(self, image: np.ndarray, dicom_series: DICOMSeries, output_dir: Path):
+        # Generate SOP instance UID, and use it as dcm file name too
+        seg_sop_instance_uid = hd.UID()  # generate_uid() can be used too.
+
+        if not output_dir.is_dir():
+            try:
+                output_dir.mkdir(parents=True, exist_ok=True)
+            except Exception:
+                raise ValueError("output_dir {output_dir} does not exist and failed to be created.") from None
+        output_path = output_dir / f"{seg_sop_instance_uid}{DICOMSegmentationWriterOperator.DCM_EXTENSION}"
 
         dicom_dataset_list = [i.get_native_sop_instance() for i in dicom_series.get_sop_instances()]
 
@@ -275,18 +284,37 @@ def create_dicom_seg(self, image: np.ndarray, dicom_series: DICOMSeries, file_pa
             segment_descriptions=self._seg_descs,
             series_instance_uid=hd.UID(),
             series_number=random_with_n_digits(4),
-            sop_instance_uid=hd.UID(),
+            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",
         )
-        seg.save_as(file_path)
+
+        # Adding a few tags that are not in the Dataset
+        # Also try to set the custom tags that are of string type
+        dt_now = datetime.datetime.now()
+        seg.SeriesDate = dt_now.strftime("%Y%m%d")
+        seg.SeriesTime = dt_now.strftime("%H%M%S")
+        seg.TimezoneOffsetFromUTC = (
+            dt_now.astimezone().isoformat()[-6:].replace(":", "")
+        )  # '2022-09-27T22:36:20.143857-07:00'
+
+        if self._custom_tags:
+            for k, v in self._custom_tags.items():
+                if isinstance(k, str) and isinstance(v, str):
+                    try:
+                        seg[k].value = v
+                    except Exception as ex:
+                        # Best effort for now.
+                        logging.warning(f"Tag {k} was not written, due to {ex}")
+
+        seg.save_as(output_path)
 
         try:
             # Test reading back
-            _ = self._read_from_dcm(str(file_path))
+            _ = self._read_from_dcm(str(output_path))
         except Exception as ex:
             print("DICOMSeg creation failed. Error:\n{}".format(ex))
             raise
@@ -356,8 +384,8 @@ def test():
     from monai.deploy.operators.dicom_series_to_volume_operator import DICOMSeriesToVolumeOperator
 
     current_file_dir = Path(__file__).parent.resolve()
-    data_path = current_file_dir.joinpath("../../../examples/ai_spleen_seg_data/dcm")
-    out_path = current_file_dir.joinpath("../../../examples/output_seg_op/dcm_seg_test.dcm")
+    data_path = current_file_dir.joinpath("../../../inputs/spleen_ct_tcia")
+    out_dir = Path("output_seg_op").absolute()
     segment_descriptions = [
         SegmentDescription(
             segment_label="Spleen",
@@ -385,7 +413,7 @@ def test():
     # Very crude thresholding
     image_numpy = (image.asnumpy() > 400).astype(np.uint8)
 
-    seg_writer.create_dicom_seg(image_numpy, series, Path(out_path).absolute())
+    seg_writer.create_dicom_seg(image_numpy, series, out_dir)
 
     # Testing with the main entry functions
     study_list = loader.load_data_to_studies(data_path.absolute())
@@ -394,7 +422,7 @@ def test():
     # Very crude thresholding
     image_numpy = (image.asnumpy() > 400).astype(np.uint8)
     image = Image(image_numpy)
-    seg_writer.process_images(image, study_selected_series_list, out_path.parent.absolute())
+    seg_writer.process_images(image, study_selected_series_list, out_dir)
 
 
 if __name__ == "__main__":

monai/deploy/operators/monai_bundle_inference_operator.py

@@ -15,6 +15,7 @@
 import pickle
 import time
 import zipfile
+from copy import deepcopy
 from pathlib import Path
 from threading import Lock
 from typing import Any, Dict, List, Optional, Tuple, Type, Union
@@ -29,12 +30,19 @@
 
 from .inference_operator import InferenceOperator
 
+MONAI_UTILS = "monai.utils"
 nibabel, _ = optional_import("nibabel", "3.2.1")
-torch, _ = optional_import("torch", "1.10.0")
+torch, _ = optional_import("torch", "1.10.2")
 
+NdarrayOrTensor, _ = optional_import("monai.config", name="NdarrayOrTensor")
+MetaTensor, _ = optional_import("monai.data.meta_tensor", name="MetaTensor")
 PostFix, _ = optional_import("monai.utils.enums", name="PostFix")  # For the default meta_key_postfix
 first, _ = optional_import("monai.utils.misc", name="first")
-ensure_tuple, _ = optional_import("monai.utils", name="ensure_tuple")
+ensure_tuple, _ = optional_import(MONAI_UTILS, name="ensure_tuple")
+convert_to_dst_type, _ = optional_import(MONAI_UTILS, name="convert_to_dst_type")
+Key, _ = optional_import(MONAI_UTILS, name="ImageMetaKey")
+MetaKeys, _ = optional_import(MONAI_UTILS, name="MetaKeys")
+SpaceKeys, _ = optional_import(MONAI_UTILS, name="SpaceKeys")
 Compose_, _ = optional_import("monai.transforms", name="Compose")
 ConfigParser_, _ = optional_import("monai.bundle", name="ConfigParser")
 MapTransform_, _ = optional_import("monai.transforms", name="MapTransform")
@@ -45,6 +53,7 @@
 MapTransform: Any = MapTransform_
 ConfigParser: Any = ConfigParser_
 
+
 __all__ = ["MonaiBundleInferenceOperator", "IOMapping", "BundleConfigNames"]
 
 
@@ -198,7 +207,7 @@ def _ensure_str_list(config_names):
 #       operator may choose to pass in a accessible bundle path at development and packaging stage. Ideally,
 #       the bundle path should be passed in by the Packager, e.g. via env var, when the App is initialized.
 #       As of now, the Packager only passes in the model path after the App including all operators are init'ed.
-@md.env(pip_packages=["monai==0.9.0", "torch>=1.10.02", "numpy>=1.21", "nibabel>=3.2.1"])
+@md.env(pip_packages=["monai>=1.0.0", "torch>=1.10.02", "numpy>=1.21", "nibabel>=3.2.1"])
 class MonaiBundleInferenceOperator(InferenceOperator):
     """This inference operator automates the inference operation for a given MONAI Bundle.
 
@@ -477,14 +486,19 @@ def compute(self, op_input: InputContext, op_output: OutputContext, context: Exe
 
             start = time.time()
             for name in self._inputs.keys():
-                value, metadata = self._receive_input(name, op_input, context)
+                # Input MetaTensor creation is based on the same logic in monai LoadImage
+                # value: NdarrayOrTensor  # MyPy complaints
+                value, meta_data = self._receive_input(name, op_input, context)
+                value = convert_to_dst_type(value, dst=value)[0]
+                if not isinstance(meta_data, dict):
+                    raise ValueError("`meta_data` must be a dict.")
+                value = MetaTensor.ensure_torch_and_prune_meta(value, meta_data)
                 inputs[name] = value
-                if metadata:
-                    inputs[(f"{name}_{self._meta_key_postfix}")] = metadata
+                # Named metadata dict not needed any more, as it is in the MetaTensor
 
             inputs = self.pre_process(inputs)
-            first_input = inputs.pop(first_input_name)[None].to(self._device)  # select first input
-            input_metadata = inputs.get(f"{first_input_name}_{self._meta_key_postfix}", None)
+            first_input_v = inputs[first_input_name]  # keep a copy of value for later use
+            first_input = inputs.pop(first_input_name)[None].to(self._device)
 
             # select other tensor inputs
             other_inputs = {k: v[None].to(self._device) for k, v in inputs.items() if isinstance(v, torch.Tensor)}
@@ -496,9 +510,10 @@ def compute(self, op_input: InputContext, op_output: OutputContext, context: Exe
             outputs: Any = self.predict(data=first_input, **other_inputs)  # Use type Any to quiet MyPy complaints.
             logging.debug(f"Inference elapsed time (seconds): {time.time() - start}")
 
-            # TODO: Does this work for models where multiple outputs are returned?
-            # Note that the inputs are needed because the invert transform requires it.
+            # Note that the `inputs` are needed because the `invert` transform requires it. With metadata being
+            # in the keyed MetaTensors of inputs, e.g. `image`, the whole inputs are needed.
             start = time.time()
+            inputs[first_input_name] = first_input_v
             kw_args = {self.kw_preprocessed_inputs: inputs}
             outputs = self.post_process(ensure_tuple(outputs)[0], **kw_args)
             logging.debug(f"Post-processing elapsed time (seconds): {time.time() - start}")
@@ -512,7 +527,7 @@ def compute(self, op_input: InputContext, op_output: OutputContext, context: Exe
         for name in self._outputs.keys():
             # Note that the input metadata needs to be passed.
             # Please see the comments in the called function for the reasons.
-            self._send_output(output_dict[name], name, input_metadata, op_output, context)
+            self._send_output(output_dict[name], name, first_input_v.meta, op_output, context)
 
     def predict(self, data: Any, *args, **kwargs) -> Union[Image, Any, Tuple[Any, ...], Dict[Any, Any]]:
         """Predicts output using the inferer."""
@@ -698,7 +713,7 @@ def _convert_from_image_dicom_source(self, img: Image) -> Tuple[np.ndarray, Dict
         """
 
         img_meta_dict: Dict = img.metadata()
-        meta_dict = {key: img_meta_dict[key] for key in img_meta_dict.keys()}
+        meta_dict = deepcopy(img_meta_dict)
 
         # The MONAI ImageReader, e.g. the ITKReader, arranges the image spatial dims in WHD,
         # so the "spacing" needs to be expressed in such an order too, as expected by the transforms.
@@ -709,18 +724,20 @@ def _convert_from_image_dicom_source(self, img: Image) -> Tuple[np.ndarray, Dict
                 img_meta_dict["depth_pixel_spacing"],
             ]
         )
-        meta_dict["original_affine"] = np.asarray(img_meta_dict.get("nifti_affine_transform", None))
-        meta_dict["affine"] = meta_dict["original_affine"]
+        # Use defines MetaKeys directly
+        meta_dict[MetaKeys.ORIGINAL_AFFINE] = np.asarray(img_meta_dict.get("nifti_affine_transform", None))
+        meta_dict[MetaKeys.AFFINE] = meta_dict[MetaKeys.ORIGINAL_AFFINE].copy()
+        meta_dict[MetaKeys.SPACE] = SpaceKeys.LPS  # not using SpaceKeys.RAS or affine_lps_to_ras
 
         # Similarly the Image ndarray has dim order DHW, to be rearranged to WHD.
         # TODO: Need to revisit this once multi-channel image is supported and the Image class itself
         #       is enhanced to provide attributes or functions for channel and dim order details.
         converted_image = np.swapaxes(img.asnumpy(), 0, 2)
 
         # The spatial shape is then that of the converted image, in WHD
-        meta_dict["spatial_shape"] = np.asarray(converted_image.shape)
+        meta_dict[MetaKeys.SPATIAL_SHAPE] = np.asarray(converted_image.shape)
 
         # Well, now channel for now.
-        meta_dict["original_channel_dim"] = "no_channel"
+        meta_dict[MetaKeys.ORIGINAL_CHANNEL_DIM] = "no_channel"
 
         return converted_image, meta_dict