Migrate more apps

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

Author: MMelQin

examples/apps/ai_pancrea_seg_app/__init__.py

@@ -1,3 +1,14 @@
+# Copyright 2021-2023 MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 import os
 import sys
 

examples/apps/ai_pancrea_seg_app/__main__.py

@@ -1,4 +1,18 @@
+# Copyright 2021-2023 MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 from app import AIPancreasSegApp
 
+from monai.deploy.logger import load_env_log_level
+
 if __name__ == "__main__":
-    AIPancreasSegApp(do_run=True)
+    load_env_log_level()
+    AIPancreasSegApp().run()

examples/apps/ai_pancrea_seg_app/app.py

@@ -1,4 +1,4 @@
-# Copyright 2021-2022 MONAI Consortium
+# Copyright 2021-2023 MONAI Consortium
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
@@ -10,14 +10,16 @@
 # limitations under the License.
 
 import logging
+from pathlib import Path
 
 # Required for setting SegmentDescription attributes. Direct import as this is not part of App SDK package.
 from pydicom.sr.codedict import codes
 
-import monai.deploy.core as md
-from monai.deploy.core import Application, resource
+from monai.deploy.conditions import CountCondition
+from monai.deploy.core import AppContext, Application
 from monai.deploy.core.domain import Image
 from monai.deploy.core.io_type import IOType
+from monai.deploy.logger import load_env_log_level
 from monai.deploy.operators.dicom_data_loader_operator import DICOMDataLoaderOperator
 from monai.deploy.operators.dicom_seg_writer_operator import DICOMSegmentationWriterOperator, SegmentDescription
 from monai.deploy.operators.dicom_series_selector_operator import DICOMSeriesSelectorOperator
@@ -28,12 +30,28 @@
     MonaiBundleInferenceOperator,
 )
 
+# from monai.deploy.operators.stl_conversion_operator import STLConversionOperator  # uncomment if need be used
 
-@resource(cpu=1, gpu=1, memory="7Gi")
-@md.env(pip_packages=["torch>=1.12.0"])
+# @resource(cpu=1, gpu=1, memory="7Gi")
+# @md.env(pip_packages=["torch>=1.12.0"])
 # pip_packages can be a string that is a path(str) to requirements.txt file or a list of packages.
 # The monai pkg is not required by this class, instead by the included operators.
 class AIPancreasSegApp(Application):
+    """Demonstrates inference with built-in MONAI Bundle inference operator with DICOM files as input/output
+
+    This application loads a set of DICOM instances, select the appropriate series, converts the series to
+    3D volume image, performs inference with the built-in MONAI Bundle inference operator, including pre-processing
+    and post-processing, saves the segmentation image in a DICOM Seg OID in an instance file, and optionally the
+    surface mesh in STL format.
+
+    Pertinent MONAI Bundle:
+      https://github.com/Project-MONAI/model-zoo/tree/dev/models/pancreas_ct_dints_segmentation
+
+    Execution Time Estimate:
+      With a Nvidia GV100 32GB GPU, for a input of 200 DICOM instances, execution time is around 90 seconds, and
+      for 500 instance 180 seconds.
+    """
+
     def __init__(self, *args, **kwargs):
         """Creates an application instance."""
         self._logger = logging.getLogger("{}.{}".format(__name__, type(self).__name__))
@@ -50,10 +68,17 @@ def compose(self):
 
         logging.info(f"Begin {self.compose.__name__}")
 
+        app_context = AppContext({})  # Let it figure out all the attributes without overriding
+        app_input_path = Path(app_context.input_path)
+        app_output_path = Path(app_context.output_path)
+        model_path = Path(app_context.model_path)
+
         # Create the custom operator(s) as well as SDK built-in operator(s).
-        study_loader_op = DICOMDataLoaderOperator()
-        series_selector_op = DICOMSeriesSelectorOperator(Sample_Rules_Text)
-        series_to_vol_op = DICOMSeriesToVolumeOperator()
+        study_loader_op = DICOMDataLoaderOperator(
+            self, CountCondition(self, 1), input_folder=app_input_path, name="study_loader_op"
+        )
+        series_selector_op = DICOMSeriesSelectorOperator(self, rules=Sample_Rules_Text, name="series_selector_op")
+        series_to_vol_op = DICOMSeriesToVolumeOperator(self, name="series_to_vol_op")
 
         # Create the inference operator that supports MONAI Bundle and automates the inference.
         # The IOMapping labels match the input and prediction keys in the pre and post processing.
@@ -62,15 +87,15 @@ def compose(self):
         # environment, so when the app is packaged into a MAP, the operator can complete the bundle parsing
         # during init to provide the optional packages info, parsed from the bundle, to the packager
         # for it to install the packages in the MAP docker image.
-        # Setting output IOType to DISK only works only for leaf operators, not the case in this example.
-        #
-        # Pertinent MONAI Bundle:
-        #   https://github.com/Project-MONAI/model-zoo/tree/dev/models/spleen_ct_segmentation
 
-        bundle_spleen_seg_op = MonaiBundleInferenceOperator(
+        config_names = BundleConfigNames(config_names=["inference"])  # Same as the default
+        bundle_seg_op = MonaiBundleInferenceOperator(
+            self,
             input_mapping=[IOMapping("image", Image, IOType.IN_MEMORY)],
             output_mapping=[IOMapping("pred", Image, IOType.IN_MEMORY)],
-            bundle_config_names=BundleConfigNames(config_names=["inference"]),  # Same as the default
+            bundle_config_names=config_names,
+            bundle_path=model_path,
+            name="bundle_seg_op",
         )
 
         # Create DICOM Seg writer providing the required segment description for each segment with
@@ -91,25 +116,31 @@ def compose(self):
         custom_tags = {"SeriesDescription": "AI generated Seg for research use only. Not for clinical use."}
 
         dicom_seg_writer = DICOMSegmentationWriterOperator(
-            segment_descriptions=segment_descriptions, custom_tags=custom_tags
+            self,
+            segment_descriptions=segment_descriptions,
+            custom_tags=custom_tags,
+            output_folder=app_output_path,
+            name="dicom_seg_writer",
         )
 
         # 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.
-        self.add_flow(study_loader_op, series_selector_op, {"dicom_study_list": "dicom_study_list"})
+        self.add_flow(study_loader_op, series_selector_op, {("dicom_study_list", "dicom_study_list")})
         self.add_flow(
-            series_selector_op, series_to_vol_op, {"study_selected_series_list": "study_selected_series_list"}
+            series_selector_op, series_to_vol_op, {("study_selected_series_list", "study_selected_series_list")}
         )
-        self.add_flow(series_to_vol_op, bundle_spleen_seg_op, {"image": "image"})
+        self.add_flow(series_to_vol_op, bundle_seg_op, {("image", "image")})
         # Note below the dicom_seg_writer requires two inputs, each coming from a source operator.
         self.add_flow(
-            series_selector_op, dicom_seg_writer, {"study_selected_series_list": "study_selected_series_list"}
+            series_selector_op, dicom_seg_writer, {("study_selected_series_list", "study_selected_series_list")}
         )
-        self.add_flow(bundle_spleen_seg_op, dicom_seg_writer, {"pred": "seg_image"})
+        self.add_flow(bundle_seg_op, dicom_seg_writer, {("pred", "seg_image")})
         # Create the surface mesh STL conversion operator and add it to the app execution flow, if needed, by
         # uncommenting the following couple lines.
-        # stl_conversion_op = STLConversionOperator(output_file="stl/spleen.stl")
-        # self.add_flow(bundle_spleen_seg_op, stl_conversion_op, {"pred": "image"})
+        # stl_conversion_op = STLConversionOperator(
+        #     self, output_file=app_output_path.joinpath("stl/spleen.stl"), name="stl_conversion_op"
+        # )
+        # self.add_flow(bundle_seg_op, stl_conversion_op, {("pred", "image")})
 
         logging.info(f"End {self.compose.__name__}")
 
@@ -140,5 +171,5 @@ def compose(self):
     # e.g.
     #     monai-deploy exec app.py -i input -m model/model.ts
     #
-    logging.basicConfig(level=logging.DEBUG)
-    app_instance = AIPancreasSegApp(do_run=True)
+    load_env_log_level()
+    AIPancreasSegApp().run()

examples/apps/ai_spleen_seg_app/__init__.py

@@ -1,3 +1,14 @@
+# Copyright 2021-2023 MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 import os
 import sys
 

examples/apps/ai_spleen_seg_app/__main__.py

@@ -1,3 +1,14 @@
+# Copyright 2021-2023 MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 from app import AISpleenSegApp
 
 from monai.deploy.logger import load_env_log_level

examples/apps/ai_spleen_seg_app/app.py

@@ -1,4 +1,4 @@
-# Copyright 2021-2022 MONAI Consortium
+# Copyright 2021-2023 MONAI Consortium
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
@@ -36,6 +36,20 @@
 # pip_packages can be a string that is a path(str) to requirements.txt file or a list of packages.
 # The monai pkg is not required by this class, instead by the included operators.
 class AISpleenSegApp(Application):
+    """Demonstrates inference with built-in MONAI Bundle inference operator with DICOM files as input/output
+
+    This application loads a set of DICOM instances, select the appropriate series, converts the series to
+    3D volume image, performs inference with the built-in MONAI Bundle inference operator, including pre-processing
+    and post-processing, save the segmentation image in a DICOM Seg OID in an instance file, and optionally the
+    surface mesh in STL format.
+
+    Pertinent MONAI Bundle:
+      https://github.com/Project-MONAI/model-zoo/tree/dev/models/spleen_ct_segmentation
+
+    Execution Time Estimate:
+      With a Nvidia GV100 32GB GPU, for a input of 500 DICOM instances, execution time is around 25 seconds.
+    """
+
     def __init__(self, *args, **kwargs):
         """Creates an application instance."""
         self._logger = logging.getLogger("{}.{}".format(__name__, type(self).__name__))
@@ -71,10 +85,6 @@ def compose(self):
         # environment, so when the app is packaged into a MAP, the operator can complete the bundle parsing
         # during init to provide the optional packages info, parsed from the bundle, to the packager
         # for it to install the packages in the MAP docker image.
-        # Setting output IOType to DISK only works only for leaf operators, not the case in this example.
-        #
-        # Pertinent MONAI Bundle:
-        #   https://github.com/Project-MONAI/model-zoo/tree/dev/models/spleen_ct_segmentation
 
         config_names = BundleConfigNames(config_names=["inference"])  # Same as the default
 

monai/deploy/operators/monai_bundle_inference_operator.py

@@ -294,11 +294,7 @@ class MonaiBundleInferenceOperator(InferenceOperator):
     the `DICOMSeriesToVolumeOperator`, and passing a segmentation `Image` to the `DICOMSegmentationWriterOperator`.
     In such cases, the I/O storage type can only be `IN_MEMORY` due to the restrictions imposed by the application executor.
 
-    The following capabilites has been deprecated:
-    However, when used as the first operator in an application, its input storage type needs to be `DISK`, and the file needs
-    to be a Python pickle file, e.g. containing an `Image` instance. When used as the last operator, its output storage type
-    also needs to `DISK` with the path being the application's output folder, and the operator's output will be saved as
-    a pickle file whose name is the same as the output name.
+    For the time being, the input and output to this operator are limited to in_memory object.
     """
 
     known_io_data_types = {
@@ -526,7 +522,9 @@ def _add_outputs(self, output_mapping: List[IOMapping]):
 
     def setup(self, spec: OperatorSpec):
         [spec.input(v.label) for v in self._input_mapping]
-        [spec.output(v.label) for v in self._output_mapping]
+        for v in self._output_mapping:
+            if v.storage_type == IOType.IN_MEMORY:  # As of now the output port type can only be in_memory object.
+                spec.output(v.label)
 
     def compute(self, op_input, op_output, context):
         """Infers with the input(s) and saves the prediction result(s) to output