Migrated stl writer and the liver tumor seg example.

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

Author: MMelQin

examples/apps/ai_livertumor_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_livertumor_seg_app/__main__.py

@@ -1,4 +1,15 @@
+# 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 AILiverTumorApp
 
 if __name__ == "__main__":
-    AILiverTumorApp(do_run=True)
+    AILiverTumorApp().run()

examples/apps/ai_livertumor_seg_app/app.py

@@ -1,4 +1,4 @@
-# Copyright 2021 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,18 +10,23 @@
 # limitations under the License.
 
 import logging
+from pathlib import Path
 
 from livertumor_seg_operator import LiverTumorSegOperator
 
 # Required for setting SegmentDescription attributes. Direct import as this is not part of App SDK package.
 from pydicom.sr.codedict import codes
 
-from monai.deploy.core import Application, resource
+from monai.deploy.conditions import CountCondition
+from monai.deploy.core import AppContext, Application
+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
 from monai.deploy.operators.dicom_series_to_volume_operator import DICOMSeriesToVolumeOperator
-from monai.deploy.operators.publisher_operator import PublisherOperator
+from monai.deploy.operators.stl_conversion_operator import STLConversionOperator
+
+# from monai.deploy.operators.publisher_operator import PublisherOperator
 
 # This is a sample series selection rule in JSON, simply selecting CT series.
 # If the study has more than 1 CT series, then all of them will be selected.
@@ -45,7 +50,7 @@
 """
 
 
-@resource(cpu=1, gpu=1, memory="7Gi")
+# @resource(cpu=1, gpu=1, memory="7Gi")
 # 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 AILiverTumorApp(Application):
@@ -64,16 +69,27 @@ def run(self, *args, **kwargs):
     def compose(self):
         """Creates the app specific operators and chain them up in the processing DAG."""
 
-        self._logger.debug(f"Begin {self.compose.__name__}")
+        self._logger.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)
+
+        self._logger.info(f"App input and output path: {app_input_path}, {app_output_path}")
+
         # Creates the custom operator(s) as well as SDK built-in operator(s).
-        study_loader_op = DICOMDataLoaderOperator()
-        series_selector_op = DICOMSeriesSelectorOperator(rules=Sample_Rules_Text)
-        series_to_vol_op = DICOMSeriesToVolumeOperator()
+        study_loader_op = DICOMDataLoaderOperator(
+            self, CountCondition(self, 1), input_folder=app_input_path, name="dcm_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")
         # Model specific inference operator, supporting MONAI transforms.
-        liver_tumor_seg_op = LiverTumorSegOperator()
+        liver_tumor_seg_op = LiverTumorSegOperator(
+            self, model_path=model_path, output_folder=app_output_path, name="seg_op"
+        )
 
         # Create the publisher operator
-        publisher_op = PublisherOperator()
+        stl_op = STLConversionOperator(self, output_file=app_output_path.joinpath("stl/mesh.stl"), name="stl_op")
 
         # Create DICOM Seg writer providing the required segment description for each segment with
         # the actual algorithm and the pertinent organ/tissue.
@@ -105,24 +121,27 @@ def compose(self):
             ),
         ]
 
-        dicom_seg_writer = DICOMSegmentationWriterOperator(segment_descriptions)
+        dicom_seg_writer = DICOMSegmentationWriterOperator(
+            self, segment_descriptions=segment_descriptions, output_folder=app_output_path, name="dcm_seg_writer_op"
+        )
         # 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, liver_tumor_seg_op, {"image": "image"})
-        # Add the publishing operator to save the input and seg images for Render Server.
-        # Note the PublisherOperator has temp impl till a proper rendering module is created.
-        self.add_flow(liver_tumor_seg_op, publisher_op, {"saved_images_folder": "saved_images_folder"})
+        self.add_flow(series_to_vol_op, liver_tumor_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(liver_tumor_seg_op, dicom_seg_writer, {"seg_image": "seg_image"})
+        self.add_flow(liver_tumor_seg_op, dicom_seg_writer, {("seg_image", "seg_image")})
+
+        # Add the stl mesh operator to save the mesh in stl format.
+        self.add_flow(liver_tumor_seg_op, stl_op, {("seg_image", "image")})
 
-        self._logger.debug(f"End {self.compose.__name__}")
+        self._logger.info(f"End {self.compose.__name__}")
 
 
 if __name__ == "__main__":
@@ -134,5 +153,4 @@ def compose(self):
     #     python3 app.py -i input -m model/model.ts
     #
     logging.basicConfig(level=logging.DEBUG)
-    app_instance = AILiverTumorApp()  # Optional params' defaults are fine.
-    app_instance.run()
+    AILiverTumorApp().run()

examples/apps/ai_livertumor_seg_app/livertumor_seg_operator.py

@@ -1,4 +1,4 @@
-# Copyright 2021 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,11 +10,11 @@
 # limitations under the License.
 
 import logging
+from pathlib import Path
 
 from numpy import uint8
 
-import monai.deploy.core as md
-from monai.deploy.core import DataPath, ExecutionContext, Image, InputContext, IOType, Operator, OutputContext
+from monai.deploy.core import ConditionType, Fragment, Operator, OperatorSpec
 from monai.deploy.operators.monai_seg_inference_operator import InMemImageReader, MonaiSegInferenceOperator
 from monai.transforms import (
     Activationsd,
@@ -30,10 +30,10 @@
 )
 
 
-@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>=1.0.0", "torch>=1.5", "numpy>=1.21", "nibabel"])
+# @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>=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.
 
@@ -49,27 +49,48 @@ class LiverTumorSegOperator(Operator):
     Note that the App SDK InMemImageReader, derived from MONAI ImageReader, is passed to LoadImaged.
     This derived reader is needed to parse the in memory image object, and return the expected data structure.
     Loading of the model, and predicting using in-proc PyTorch inference is done by MonaiSegInferenceOperator.
+
+    Named Input:
+        image: Image object.
+
+    Named Outputs:
+        seg_image: Image object of the segmentation object.
+        saved_images_folder: Path to the folder with intermediate image output, not requiring a downstream receiver.
     """
 
-    def __init__(self):
+    DEFAULT_OUTPUT_FOLDER = Path.cwd() / "saved_images_folder"
+
+    def __init__(self, frament: Fragment, *args, model_path: Path, output_folder: Path = None, **kwargs):
         self.logger = logging.getLogger("{}.{}".format(__name__, type(self).__name__))
-        super().__init__()
         self._input_dataset_key = "image"
         self._pred_dataset_key = "pred"
 
-    def compute(self, op_input: InputContext, op_output: OutputContext, context: ExecutionContext):
-        input_image = op_input.get("image")
+        self.model_path = model_path
+        self.output_folder = output_folder if output_folder else LiverTumorSegOperator.DEFAULT_OUTPUT_FOLDER
+        self.output_folder.mkdir(parents=True, exist_ok=True)
+        self.fragement = frament  # Cache and later pass the Fragment/Application to contained operator(s)
+        self.input_name_image = "image"
+        self.output_name_seg = "seg_image"
+
+        self.fragement = frament  # Cache and later pass the Fragment/Application to contained operator(s)
+        super().__init__(frament, *args, **kwargs)
+
+    def setup(self, spec: OperatorSpec):
+        spec.input(self.input_name_image)
+        spec.output(self.output_name_seg)
+
+    def compute(self, op_input, op_output, context):
+        input_image = op_input.receive(self.input_name_image)
         if not input_image:
             raise ValueError("Input image is not found.")
 
         # Get the output path from the execution context for saving file(s) to app output.
-        # Without using this path, operator would be saving files to its designated path, e.g.
-        # $PWD/.monai_workdir/operators/6048d75a-5de1-45b9-8bd1-2252f88827f2/0/output
-        op_output_folder_name = DataPath("saved_images_folder")
-        op_output.set(op_output_folder_name, "saved_images_folder")
-        op_output_folder_path = op_output.get("saved_images_folder").path
-        op_output_folder_path.mkdir(parents=True, exist_ok=True)
-        print(f"Operator output folder path: {op_output_folder_path}")
+        # Without using this path, operator would be saving files to its designated path
+        # op_output_folder_name = "saved_images_folder"
+        # op_output.set(op_output_folder_name, "saved_images_folder")
+        # op_output_folder_path = Path(op_output_folder_name)  # op_output.get("saved_images_folder").path
+        # op_output_folder_path.mkdir(parents=True, exist_ok=True)
+        # print(f"Operator output folder path: {op_output_folder_path}")
 
         # This operator gets an in-memory Image object, so a specialized ImageReader is needed.
         _reader = InMemImageReader(input_image)
@@ -78,28 +99,30 @@ def compute(self, op_input: InputContext, op_output: OutputContext, context: Exe
         # They are both saved in the same subfolder of the application output folder, with names
         # distinguished by postfix. They can also be save in different subfolder if need be.
         # These images files can then be packaged for rendering.
-        pre_transforms = self.pre_process(_reader, op_output_folder_path)
-        post_transforms = self.post_process(pre_transforms, op_output_folder_path)
+        pre_transforms = self.pre_process(_reader, str(self.output_folder))
+        post_transforms = self.post_process(pre_transforms, str(self.output_folder))
 
         # Delegates inference and saving output to the built-in operator.
         infer_operator = MonaiSegInferenceOperator(
-            (
+            self.fragement,
+            roi_size=(
                 160,
                 160,
                 160,
             ),
-            pre_transforms,
-            post_transforms,
+            pre_transforms=pre_transforms,
+            post_transforms=post_transforms,
             overlap=0.6,
             model_name="",
+            model_path=self.model_path,
         )
 
         # Setting the keys used in the dictironary based transforms may change.
         infer_operator.input_dataset_key = self._input_dataset_key
         infer_operator.pred_dataset_key = self._pred_dataset_key
 
-        # Now let the built-in operator handles the work with the I/O spec and execution context.
-        infer_operator.compute(op_input, op_output, context)
+        # Now let the built-in operator handle the work with the I/O spec and execution context.
+        op_output.emit(infer_operator.compute_impl(input_image, context), self.output_name_seg)
 
     def pre_process(self, img_reader, out_dir: str = "./input_images") -> Compose:
         """Composes transforms for preprocessing input before predicting on a model."""