Updated Jupyter Notebook and example apps to use the new operator APIs.

Signed-off-by: mmelqin <[email protected]>

Author: MMelQin

examples/apps/ai_livertumor_seg_app/app.py

@@ -61,15 +61,19 @@ def compose(self):
         # Create the processing pipeline, by specifying the upstream and downstream 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(series_selector_op, series_to_vol_op, {"dicom_series": "dicom_series"})
+        self.add_flow(
+            series_selector_op, series_to_vol_op, {"study_selected_series_list": "study_selected_series_list"}
+        )
         self.add_flow(series_to_vol_op, unetr_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(unetr_seg_op, publisher_op, {"saved_images_folder": "saved_images_folder"})
         # Note below the dicom_seg_writer requires two inputs, each coming from a upstream operator.
         # Also note that the DICOMSegmentationWriterOperator may throw exception with some inputs.
         #   Bug has been created to track the issue.
-        self.add_flow(series_selector_op, dicom_seg_writer, {"dicom_series": "dicom_series"})
+        self.add_flow(
+            series_selector_op, dicom_seg_writer, {"study_selected_series_list": "study_selected_series_list"}
+        )
         self.add_flow(unetr_seg_op, dicom_seg_writer, {"seg_image": "seg_image"})
 
         self._logger.debug(f"End {self.compose.__name__}")

examples/apps/ai_spleen_seg_app/app.py

@@ -39,9 +39,10 @@ def compose(self):
         """Creates the app specific operators and chain them up in the processing DAG."""
 
         self._logger.debug(f"Begin {self.compose.__name__}")
+
         # Creates the custom operator(s) as well as SDK built-in operator(s).
         study_loader_op = DICOMDataLoaderOperator()
-        series_selector_op = DICOMSeriesSelectorOperator()
+        series_selector_op = DICOMSeriesSelectorOperator(Sample_Rules_Text)
         series_to_vol_op = DICOMSeriesToVolumeOperator()
         # Model specific inference operator, supporting MONAI transforms.
         spleen_seg_op = SpleenSegOperator()
@@ -51,15 +52,37 @@ def compose(self):
         # Create the processing pipeline, by specifying the upstream and downstream 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(series_selector_op, series_to_vol_op, {"dicom_series": "dicom_series"})
+        self.add_flow(
+            series_selector_op, series_to_vol_op, {"study_selected_series_list": "study_selected_series_list"}
+        )
         self.add_flow(series_to_vol_op, spleen_seg_op, {"image": "image"})
         # Note below the dicom_seg_writer requires two inputs, each coming from a upstream operator.
-        self.add_flow(series_selector_op, dicom_seg_writer, {"dicom_series": "dicom_series"})
+        self.add_flow(
+            series_selector_op, dicom_seg_writer, {"study_selected_series_list": "study_selected_series_list"}
+        )
         self.add_flow(spleen_seg_op, dicom_seg_writer, {"seg_image": "seg_image"})
 
         self._logger.debug(f"End {self.compose.__name__}")
 
 
+# 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.
+# Please see more detail in DICOMSeriesSelectorOperator.
+Sample_Rules_Text = """
+{
+    "selections": [
+        {
+            "name": "CT Series",
+            "conditions": {
+                "StudyDescription": "(.*?)",
+                "Modality": "(?i)CT",
+                "SeriesDescription": "(.*?)"
+            }
+        }
+    ]
+}
+"""
+
 if __name__ == "__main__":
     # Creates the app and test it standalone. When running is this mode, please note the following:
     #     -m <model file>, for model file path

examples/apps/ai_unetr_seg_app/app.py

@@ -71,15 +71,19 @@ def compose(self):
         # Create the processing pipeline, by specifying the upstream and downstream 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(series_selector_op, series_to_vol_op, {"dicom_series": "dicom_series"})
+        self.add_flow(
+            series_selector_op, series_to_vol_op, {"study_selected_series_list": "study_selected_series_list"}
+        )
         self.add_flow(series_to_vol_op, unetr_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(unetr_seg_op, publisher_op, {"saved_images_folder": "saved_images_folder"})
         # Note below the dicom_seg_writer requires two inputs, each coming from a upstream operator.
         # Also note that the DICOMSegmentationWriterOperator may throw exception with some inputs.
         #   Bug has been created to track the issue.
-        self.add_flow(series_selector_op, dicom_seg_writer, {"dicom_series": "dicom_series"})
+        self.add_flow(
+            series_selector_op, dicom_seg_writer, {"study_selected_series_list": "study_selected_series_list"}
+        )
         self.add_flow(unetr_seg_op, dicom_seg_writer, {"seg_image": "seg_image"})
 
         self._logger.debug(f"End {self.compose.__name__}")

examples/apps/dicom_series_to_image_app/app.py

@@ -25,7 +25,9 @@ def compose(self):
         png_converter_op = PNGConverterOperator()
 
         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, {"dicom_series": "dicom_series"})
+        self.add_flow(
+            series_selector_op, series_to_vol_op, {"study_selected_series_list": "study_selected_series_list"}
+        )
         self.add_flow(series_to_vol_op, png_converter_op, {"image": "image"})
 
 

monai/deploy/operators/dicom_data_loader_operator.py

@@ -40,7 +40,7 @@ def compute(self, op_input: InputContext, op_output: OutputContext, context: Exe
 
         input_path = op_input.get().path
         dicom_study_list = self.load_data_to_studies(input_path)
-        op_output.set(dicom_study_list)
+        op_output.set(dicom_study_list, "dicom_study_list")
 
     def load_data_to_studies(self, input_path: Path) -> List[DICOMStudy]:
         """Load DICOM data from files into DICOMStudy objects in a list.

monai/deploy/operators/dicom_seg_writer_operator.py

@@ -38,9 +38,7 @@
 
 
 @md.input("seg_image", Image, IOType.IN_MEMORY)
-@md.input(
-    "study_selected_series_list", List[StudySelectedSeries], IOType.IN_MEMORY
-)  # "dicom_series", DICOMSeries, IOType.IN_MEMORY)
+@md.input("study_selected_series_list", List[StudySelectedSeries], IOType.IN_MEMORY)
 @md.output("dicom_seg_instance", DataPath, IOType.DISK)
 @md.env(pip_packages=["pydicom >= 1.4.2", "SimpleITK >= 2.0.0"])
 class DICOMSegmentationWriterOperator(Operator):

monai/deploy/operators/dicom_series_selector_operator.py

@@ -25,7 +25,6 @@
 
 @md.input("dicom_study_list", List[DICOMStudy], IOType.IN_MEMORY)
 @md.input("selection_rules", Dict, IOType.IN_MEMORY)  # This overides the rules in the instance.
-@md.output("dicom_series", List[DICOMSeries], IOType.IN_MEMORY)
 @md.output("study_selected_series_list", List[StudySelectedSeries], IOType.IN_MEMORY)
 class DICOMSeriesSelectorOperator(Operator):
     """This operator selects a list of DICOM Series in a DICOM Study for a given set of selection rules.
@@ -84,22 +83,27 @@ def __init__(self, rules: Text = None, all_matched: bool = False, *args, **kwarg
 
     def compute(self, op_input: InputContext, op_output: OutputContext, context: ExecutionContext):
         """Performs computation for this operator."""
+
+        dicom_study_list = None
+        selection_rules = None
         try:
             dicom_study_list = op_input.get("dicom_study_list")
+        except ItemNotExistsError as ex:
+            logging.exception(f"Failed to find input 'dicom_study_list', {ex}")
+            raise
+
+        try:
             selection_rules = op_input.get("selection_rules")
-            if not selection_rules:
-                selection_rules = self._load_rules() if self._rules_json_str else None
-            dicom_series_list, study_selected_series = self.filter(selection_rules, dicom_study_list, self._all_matched)
-            op_output.set(dicom_series_list, "dicom_series")
-            op_output.set(
-                study_selected_series,
-            )
         except ItemNotExistsError:
+            # OK for not providing selection rules.
             pass
 
-    def filter(
-        self, selection_rules, dicom_study_list, all_matched: bool = False
-    ) -> Tuple[List[SelectedSeries], List[StudySelectedSeries]]:
+        if not selection_rules:
+            selection_rules = self._load_rules() if self._rules_json_str else None
+        study_selected_series = self.filter(selection_rules, dicom_study_list, self._all_matched)
+        op_output.set(study_selected_series, "study_selected_series_list")
+
+    def filter(self, selection_rules, dicom_study_list, all_matched: bool = False) -> List[StudySelectedSeries]:
         """Selects the series with the given matching rules.
 
         If rules object is None, all series will be returned with series instance UID as the selection name.
@@ -115,15 +119,14 @@ def filter(
             all_matched (bool): Gets all matched series in a study. Defaults to False for first match only.
 
         Returns:
-            list: A list of all selected series of type SelectedSeries.
             list: A list of objects of type StudySelectedSeries.
 
         Raises:
             ValueError: If the selection_rules object does not contain "selections" attribute.
         """
 
         if not dicom_study_list or len(dicom_study_list) < 1:
-            return [], []
+            return []
 
         if not selection_rules:
             # Return all series if no selection rules are supplied
@@ -135,7 +138,6 @@ def filter(
         if not selections:
             raise ValueError('Expected "selections" not found in the rules.')
 
-        selected_series_list = []  # List of all selected DICOMSeries objects
         study_selected_series_list = []  # List of StudySelectedSeries objects
 
         for study in dicom_study_list:
@@ -153,30 +155,26 @@ def filter(
                 # Select only the first series that matches the conditions, list of one
                 series_list = self._select_series(conditions, study, all_matched)
                 if series_list and len(series_list) > 0:
-                    selected_series_list.extend(x for x in series_list)  # Add each single one
                     for series in series_list:
                         selected_series = SelectedSeries(selection_name, series)
                         study_selected_series.add_selected_series(selected_series)
 
             if len(study_selected_series.selected_series) > 0:
                 study_selected_series_list.append(study_selected_series)
 
-        return selected_series_list, study_selected_series_list
+        return study_selected_series_list
 
     def _load_rules(self):
         return json_loads(self._rules_json_str) if self._rules_json_str else None
 
-    def _select_all_series(
-        self, dicom_study_list: List[DICOMStudy]
-    ) -> Tuple[List[SelectedSeries], List[StudySelectedSeries]]:
+    def _select_all_series(self, dicom_study_list: List[DICOMStudy]) -> List[StudySelectedSeries]:
         """Select all series in studies
 
         Returns:
             list: list of DICOMSeries objects
             list: list of StudySelectedSeries objects
         """
 
-        series_list = []
         study_selected_series_list = []
         for study in dicom_study_list:
             logging.info(f"Working on study, instance UID: {study.StudyInstanceUID}")
@@ -187,9 +185,8 @@ def _select_all_series(
                 print(f"Working on series, instance UID: {str(series.SeriesInstanceUID)}")
                 selected_series = SelectedSeries(None, series)  # No selection name is known or given
                 study_selected_series.add_selected_series(selected_series)
-                series_list.append(series)
             study_selected_series_list.append(study_selected_series)
-        return series_list, study_selected_series_list
+        return study_selected_series_list
 
     def _select_series(self, attributes: dict, study: DICOMStudy, all_matched=False) -> List[DICOMSeries]:
         """Finds series whose attributes match the given attributes.

monai/deploy/operators/monai_seg_inference_operator.py

@@ -143,9 +143,9 @@ def _convert_dicom_metadata_datatype(self, metadata: Dict):
             return metadata
 
         # Try to convert data type for the well knowned attributes. Add more as needed.
-        if metadata.get("series_instance_uid", None):
+        if metadata.get("SeriesInstanceUID", None):
             try:
-                metadata["series_instance_uid"] = str(metadata["series_instance_uid"])
+                metadata["SeriesInstanceUID"] = str(metadata["SeriesInstanceUID"])
             except Exception:
                 pass
         if metadata.get("row_pixel_spacing", None):
@@ -186,7 +186,7 @@ def compute(self, op_input: InputContext, op_output: OutputContext, context: Exe
             # Need to try to convert the data type of a few metadata attributes.
             input_img_metadata = self._convert_dicom_metadata_datatype(input_image.metadata())
             # Need to give a name to the image as in-mem Image obj has no name.
-            img_name = str(input_img_metadata.get("series_instance_uid", "Img_in_context"))
+            img_name = str(input_img_metadata.get("SeriesInstanceUID", "Img_in_context"))
 
             pre_transforms: Compose = self._pre_transform
             post_transforms: Compose = self._post_transforms