WIP and initial commit

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

Author: MMelQin

examples/apps/simple_imaging_app/__main__.py

@@ -1,4 +1,10 @@
+import os
+
 from app import App
 
 if __name__ == "__main__":
-    App(do_run=True)
+    app = App()
+
+    # Config if need to, none for now
+    app.config(os.path.join(os.path.dirname(__file__), "simple_imaging_app.yaml"))
+    app.run()

examples/apps/simple_imaging_app/app.py

@@ -9,16 +9,32 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import os
+from pathlib import Path
+
 from gaussian_operator import GaussianOperator
 from median_operator import MedianOperator
 from sobel_operator import SobelOperator
 
-from monai.deploy.core import Application, env, resource
+from monai.deploy.conditions import CountCondition
+from monai.deploy.core import Application
+from monai.deploy.logger import load_env_log_level
+
+# Input path should be taken care of by the base app.
+# Without it being done yet, try to refer to MAP spec
+# for the well-known env vars
+
+
+DEFAULT_IN_PATH = Path(os.path.dirname(__file__)) / "input"
+DEFAULT_OUT_PATH = Path(os.path.dirname(__file__)) / "output"
 
+sample_data_path = Path(os.environ.get("MONAI_INPUTPATH", DEFAULT_IN_PATH))
+output_data_path = Path(os.environ.get("MONAI_OUTPUTPATH", DEFAULT_OUT_PATH))
 
-@resource(cpu=1)
-# pip_packages can be a string that is a path(str) to requirements.txt file or a list of packages.
-@env(pip_packages=["scikit-image >= 0.17.2"])
+
+# @resource(cpu=1)
+# # pip_packages can be a string that is a path(str) to requirements.txt file or a list of packages.
+# @env(pip_packages=["scikit-image >= 0.17.2"])
 class App(Application):
     """This is a very basic application.
 
@@ -38,16 +54,31 @@ def compose(self):
         Each operator has a single input and a single output port.
         Each operator performs some kind of image processing function.
         """
-        sobel_op = SobelOperator()
-        median_op = MedianOperator()
-        gaussian_op = GaussianOperator()
-
-        self.add_flow(sobel_op, median_op)
-        # self.add_flow(sobel_op, median_op, {"image": "image"})
-        # self.add_flow(sobel_op, median_op, {"image": {"image"}})
-
-        self.add_flow(median_op, gaussian_op)
+        print(f"sample_data_path: {sample_data_path}")
+        sobel_op = SobelOperator(self, CountCondition(self, 1), input_folder=sample_data_path, name="sobel_op")
+        median_op = MedianOperator(self, name="median_op")
+        gaussian_op = GaussianOperator(self, output_folder=output_data_path, name="gaussian_op")
+        self.add_flow(
+            sobel_op,
+            median_op,
+            {
+                ("out1", "in1"),
+            },
+        )  # Identifing port optional for single port cases
+        self.add_flow(
+            median_op,
+            gaussian_op,
+            {
+                (
+                    "out1",
+                    "in1",
+                )
+            },
+        )
 
 
 if __name__ == "__main__":
-    App(do_run=True)
+    load_env_log_level()
+    app = App()
+    app.config(os.path.join(os.path.dirname(__file__), "simple_imaing_app.yaml"))
+    app.run()

examples/apps/simple_imaging_app/gaussian_operator.py

@@ -9,12 +9,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import monai.deploy.core as md
-from monai.deploy.core import DataPath, ExecutionContext, Image, InputContext, IOType, Operator, OutputContext
+import os
+from pathlib import Path
+
+from skimage.filters import gaussian
+from skimage.io import imsave
+
+from monai.deploy.core import Operator, OperatorSpec
 
 
-@md.input("image", Image, IOType.IN_MEMORY)
-@md.output("image", DataPath, IOType.DISK)
 # If `pip_packages` is specified, the definition will be aggregated with the package dependency list of other
 # operators and the application in packaging time.
 # @md.env(pip_packages=["scikit-image >= 0.17.2"])
@@ -24,13 +27,37 @@ class GaussianOperator(Operator):
     It ingests a single input and provides a single output.
     """
 
-    def compute(self, op_input: InputContext, op_output: OutputContext, context: ExecutionContext):
-        from skimage.filters import gaussian
-        from skimage.io import imsave
+    DEFAULT_OUTPUT_FOLDER = Path(os.path.join(os.path.dirname(__file__))) / "output"
+
+    def __init__(self, *args, output_folder: Path, **kwargs):
+        # If `self.sigma_default` is set here (e.g., `self.sigma_default = 0.2`), then
+        # the default value by `param()` in `setup()` will be ignored.
+        # (you can just call `spec.param("sigma_default")` in `setup()` to use the
+        # default value)
+        self.output_folder = output_folder if output_folder else GaussianOperator.DEFAULT_OUTPUT_FOLDER
+        self.index = 0
+
+        # Need to call the base class constructor last
+        super().__init__(*args, **kwargs)
 
-        data_in = op_input.get().asnumpy()
-        data_out = gaussian(data_in, sigma=0.2, channel_axis=2)  # Add the param introduced in 0.19.
+    def setup(self, spec: OperatorSpec):
+        spec.input("in1")
+        # spec.output("out1")
+        spec.param("sigma_default", 0.2)
+        spec.param("channel_axis", 2)
 
-        output_folder = op_output.get().path
-        output_path = output_folder / "final_output.png"
+    def compute(self, op_input, op_output, context):
+        self.index += 1
+        print(f"# of times pperator {__name__} called: {self.index}")
+
+        data_in = op_input.receive("in1")
+        data_out = gaussian(data_in, sigma=self.sigma_default, channel_axis=self.channel_axis)
+
+        # Where to set the Application's output folder, in the context?
+        # For now, use attribute.
+        output_path = self.output_folder / "final_output.png"
         imsave(output_path, data_out)
+
+        # Let's also emit the output, even though not sure what the receiver would be
+        # CANNOT set dangling out!!!
+        # op_input.emit(data_out, "out1")

examples/apps/simple_imaging_app/median_operator.py

@@ -9,59 +9,34 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import monai.deploy.core as md
-from monai.deploy.core import ExecutionContext, Image, InputContext, IOType, Operator, OutputContext
+from skimage.filters import median
+
+from monai.deploy.core import Operator, OperatorSpec
 
 
-@md.input("image", Image, IOType.IN_MEMORY)
-@md.output("image", Image, IOType.IN_MEMORY)
 # If `pip_packages` is specified, the definition will be aggregated with the package dependency list of other
 # operators and the application in packaging time.
 # @md.env(pip_packages=["scikit-image >= 0.17.2"])
-class MedianOperatorBase(Operator):
+class MedianOperator(Operator):
     """This Operator implements a noise reduction.
 
     The algorithm is based on the median operator.
     It ingests a single input and provides a single output.
     """
 
     # Define __init__ method with super().__init__() if you want to override the default behavior.
-    def __init__(self):
-        super().__init__()
-        # Do something
-
-    def compute(self, op_input: InputContext, op_output: OutputContext, context: ExecutionContext):
-        print("Executing base operator...")
-
-
-class MedianOperator(MedianOperatorBase):
-    """This operator is a subclass of the base operator to demonstrate the usage of inheritance."""
-
-    # Define __init__ method with super().__init__() if you want to override the default behavior.
-    def __init__(self):
-        super().__init__()
-        # Do something
-
-    def compute(self, op_input: InputContext, op_output: OutputContext, context: ExecutionContext):
-        # Execute the base operator's compute method.
-        super().compute(op_input, op_output, context)
-
-        from skimage.filters import median
-
-        # `context.input.get().path` (Path) is the file/folder path of the input data from the application's context.
-        # `context.output.get().path` (Path) is the file/folder path of the output data from the application's context.
-        # `context.models.get(model_name)` returns a model instance
-        #  (a null model would be returned if model is not available)
-        # If model_name is not specified and only one model exists, it returns that model.
-        model = context.models.get()  # a model object that inherits Model class
-
-        # Get a model instance if exists
-        if model:  # if model is not a null model
-            print(model.items())
-            # # model.path for accessing the model's path
-            # # model.name for accessing the model's name
-            # result = model(input.get().asnumpy())
-
-        data_in = op_input.get().asnumpy()
+    def __init__(self, *args, **kwargs):
+        # Need to call the base class constructor last
+        super().__init__(*args, **kwargs)
+        self.index = 0
+
+    def setup(self, spec: OperatorSpec):
+        spec.input("in1")
+        spec.output("out1")
+
+    def compute(self, op_input, op_output, context):
+        self.index += 1
+        print(f"# of times pperator {__name__} called: {self.index}")
+        data_in = op_input.receive("in1")
         data_out = median(data_in)
-        op_output.set(Image(data_out))
+        op_output.emit(data_out, "out1")  # TODO: change this to use Image class

examples/apps/simple_imaging_app/sobel_operator.py

@@ -9,29 +9,58 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import monai.deploy.core as md
-from monai.deploy.core import DataPath, ExecutionContext, Image, InputContext, IOType, Operator, OutputContext
+import os
+from pathlib import Path
 
+from monai.deploy.core import Operator, OperatorSpec
 
-@md.input("image", DataPath, IOType.DISK)
-@md.output("image", Image, IOType.IN_MEMORY)
-# If `pip_packages` is specified, the definition will be aggregated with the package dependency list of other
-# operators and the application in packaging time.
-# @md.env(pip_packages=["scikit-image >= 0.17.2"])
+
+# @md.input("image", DataPath, IOType.DISK)
+# @md.output("image", Image, IOType.IN_MEMORY)
+# # If `pip_packages` is specified, the definition will be aggregated with the package dependency list of other
+# # operators and the application in packaging time.
+# # @md.env(pip_packages=["scikit-image >= 0.17.2"])
 class SobelOperator(Operator):
     """This Operator implements a Sobel edge detector.
 
     It has a single input and single output.
     """
 
-    def compute(self, op_input: InputContext, op_output: OutputContext, context: ExecutionContext):
+    DEFAULT_INPUT_FOLDER = Path(os.path.join(os.path.dirname(__file__))) / "input"
+
+    def __init__(self, *args, input_folder: Path, **kwargs):
+        # TODO: what is this for? Many examples use this. Related to CountConditions?
+        self.index = 0
+
+        # May want to validate the path, but should really be validate when the compute
+        # is called as the input path can set for each compute call
+        self.input_folder = (
+            input_folder if (input_folder and input_folder.is_dir()) else SobelOperator.DEFAULT_INPUT_FOLDER
+        )
+
+        # Need to call the base class constructor last
+        super().__init__(*args, **kwargs)
+
+    def setup(self, spec: OperatorSpec):
+        spec.output("out1")
+        # spec.param("input_folder", Path("."))
+
+    def compute(self, op_input, op_output, context):
         from skimage import filters, io
 
-        input_path = op_input.get().path
-        if input_path.is_dir():
-            input_path = next(input_path.glob("*.*"))  # take the first file
+        self.index += 1
+        print(f"# of times pperator {__name__} called: {self.index}")
+
+        # TODO: Ideally the op_input or execution context should provide the file path
+        # to read data from, for operators that are File input based.
+        #
+        # Need to use a temporary way to get input path. e.g. value set on init
+        input_folder = self.input_folder  # op_input.get().path
+        print(f"Input from: {input_folder}")
+        if input_folder.is_dir():
+            input_file = next(input_folder.glob("*.*"))  # take the first file
 
-        data_in = io.imread(input_path)[:, :, :3]  # discard alpha channel if exists
+        data_in = io.imread(input_file)[:, :, :3]  # discard alpha channel if exists
         data_out = filters.sobel(data_in)
 
-        op_output.set(Image(data_out))
+        op_output.emit(data_out, "out1")

monai/deploy/cli/exec_command.py

@@ -16,9 +16,9 @@
 from argparse import ArgumentParser, Namespace, _SubParsersAction
 from typing import List
 
-from monai.deploy.core.datastores.factory import DatastoreFactory
-from monai.deploy.core.executors.factory import ExecutorFactory
-from monai.deploy.core.graphs.factory import GraphFactory
+# from monai.deploy.core.datastores.factory import DatastoreFactory
+# from monai.deploy.core.executors.factory import ExecutorFactory
+# from monai.deploy.core.graphs.factory import GraphFactory
 
 
 def create_exec_parser(subparser: _SubParsersAction, command: str, parents: List[ArgumentParser]) -> ArgumentParser:
@@ -37,21 +37,21 @@ def create_exec_parser(subparser: _SubParsersAction, command: str, parents: List
         type=str,
         help="Path to workspace folder (default: A temporary '.monai_workdir' folder in the current folder)",
     )
-    parser.add_argument(
-        "--graph",
-        help=f"Set Graph engine (default: {GraphFactory.DEFAULT})",
-        choices=GraphFactory.NAMES,
-    )
-    parser.add_argument(
-        "--datastore",
-        help=f"Set Datastore (default: {DatastoreFactory.DEFAULT})",
-        choices=DatastoreFactory.NAMES,
-    )
-    parser.add_argument(
-        "--executor",
-        help=f"Set Executor (default: {ExecutorFactory.DEFAULT})",
-        choices=ExecutorFactory.NAMES,
-    )
+    # parser.add_argument(
+    #     "--graph",
+    #     help=f"Set Graph engine (default: {GraphFactory.DEFAULT})",
+    #     choices=GraphFactory.NAMES,
+    # )
+    # parser.add_argument(
+    #     "--datastore",
+    #     help=f"Set Datastore (default: {DatastoreFactory.DEFAULT})",
+    #     choices=DatastoreFactory.NAMES,
+    # )
+    # parser.add_argument(
+    #     "--executor",
+    #     help=f"Set Executor (default: {ExecutorFactory.DEFAULT})",
+    #     choices=ExecutorFactory.NAMES,
+    # )
     parser.add_argument("remaining", nargs="*")
 
     return parser

monai/deploy/core/__init__.py

@@ -24,13 +24,17 @@
     OutputContext
 """
 
-from .application import Application
+from holoscan.core import *
+
+# from .application import Application
 from .domain.datapath import DataPath
 from .domain.image import Image
-from .env import env
-from .execution_context import ExecutionContext
-from .io_context import InputContext, OutputContext
-from .io_type import IOType
+
+# from .env import env
+# from .execution_context import ExecutionContext
+# from .io_context import InputContext, OutputContext
+# from .io_type import IOType
 from .models import Model, ModelFactory, NamedModel, TorchScriptModel, TritonModel
-from .operator import Operator, input, output
-from .resource import resource
+
+# from .operator import Operator, input, output
+# from .resource import resource