From f881c1b1a3fdbbaadb5f5320fae8e61a9f056460 Mon Sep 17 00:00:00 2001 From: binliu Date: Sun, 13 Oct 2024 16:54:07 +0000 Subject: [PATCH 01/15] update the first version for monai bundle operator Signed-off-by: binliu --- .../monai_bundle_deployment/CMakeLists.txt | 53 ++++ .../monai_bundle_deployment/Dockerfile | 74 +++++ .../monai_bundle_deployment/README.md | 198 ++++++++++++ .../monai_bundle_deployment/__main__.py | 27 ++ applications/monai_bundle_deployment/app.py | 282 +++++++++++++++++ applications/monai_bundle_deployment/app.yaml | 29 ++ .../monai_bundle_deployment/env_settings.sh | 6 + .../monai_bundle_deployment/metadata.json | 88 ++++++ .../monai_bundle_operator.py | 228 ++++++++++++++ .../monai_totalseg_operator.py | 283 ++++++++++++++++++ .../monai_bundle_deployment/packageHAP.sh | 45 +++ .../monai_bundle_deployment/requirements.txt | 10 + .../resources/segments_3D.png | Bin 0 -> 204763 bytes .../resources/segments_DICOM_slice.png | Bin 0 -> 236265 bytes 14 files changed, 1323 insertions(+) create mode 100644 applications/monai_bundle_deployment/CMakeLists.txt create mode 100644 applications/monai_bundle_deployment/Dockerfile create mode 100644 applications/monai_bundle_deployment/README.md create mode 100644 applications/monai_bundle_deployment/__main__.py create mode 100644 applications/monai_bundle_deployment/app.py create mode 100644 applications/monai_bundle_deployment/app.yaml create mode 100755 applications/monai_bundle_deployment/env_settings.sh create mode 100644 applications/monai_bundle_deployment/metadata.json create mode 100644 applications/monai_bundle_deployment/monai_bundle_operator.py create mode 100644 applications/monai_bundle_deployment/monai_totalseg_operator.py create mode 100755 applications/monai_bundle_deployment/packageHAP.sh create mode 100644 applications/monai_bundle_deployment/requirements.txt create mode 100644 applications/monai_bundle_deployment/resources/segments_3D.png create mode 100644 applications/monai_bundle_deployment/resources/segments_DICOM_slice.png diff --git a/applications/monai_bundle_deployment/CMakeLists.txt b/applications/monai_bundle_deployment/CMakeLists.txt new file mode 100644 index 000000000..bea672b50 --- /dev/null +++ b/applications/monai_bundle_deployment/CMakeLists.txt @@ -0,0 +1,53 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# 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. + +cmake_minimum_required(VERSION 3.20) +project(imaging_ai_segmentator CXX) + +find_package(holoscan 2.0 REQUIRED CONFIG + PATHS "/opt/nvidia/holoscan" "/workspace/holoscan-sdk/install") + +# Install application and dependencies into the install/ directory for packaging +install( + FILES __main__.py + app.py + env_settings.sh + monai_totalseg_operator.py + README.md + requirements.txt + app.yaml + DESTINATION imaging_ai_segmentator + COMPONENT "holohub-apps" +) + +install( + DIRECTORY ${CMAKE_HOME_DIRECTORY}/operators/medical_imaging + DESTINATION imaging_ai_segmentator/operators) + +# Download the associated dataset if needed +option(HOLOHUB_DOWNLOAD_DATASETS "Download datasets" ON) +if(HOLOHUB_DOWNLOAD_DATASETS) + set(DOWNLOAD_DATA_DIR ${HOLOHUB_DATA_DIR}/imaging_ai_segmentator) + + file(MAKE_DIRECTORY ${DOWNLOAD_DATA_DIR}/models) + file(MAKE_DIRECTORY ${DOWNLOAD_DATA_DIR}/dicom) + add_custom_command( + OUTPUT imaging_ai_segmentator_data + COMMAND gdown -q https://drive.google.com/uc?id=1PHpFWboimEXmMSe2vBra6T8SaCMC2SHT -O ${DOWNLOAD_DATA_DIR}/models/model.pt + COMMENT "Downloading imaging_ai_segmentator model using gdown..." + ) + add_custom_target(run ALL + DEPENDS imaging_ai_segmentator_data) +endif() \ No newline at end of file diff --git a/applications/monai_bundle_deployment/Dockerfile b/applications/monai_bundle_deployment/Dockerfile new file mode 100644 index 000000000..75a7f12e2 --- /dev/null +++ b/applications/monai_bundle_deployment/Dockerfile @@ -0,0 +1,74 @@ +# syntax=docker/dockerfile:1 + +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# 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. + + +############################################################ +# Base image +############################################################ + +ARG BASE_IMAGE +ARG GPU_TYPE + +FROM ${BASE_IMAGE} AS base + +ARG DEBIAN_FRONTEND=noninteractive + +# Holohub Environment Variables +ENV HOLOSCAN_INPUT_PATH=/var/holoscan/input +ENV HOLOSCAN_OUTPUT_PATH=/var/holoscan/output +ENV HOLOSCAN_MODEL_PATH=/opt/holoscan/models +# -------------------------------------------------------------------------- +# +# Holohub run setup +# + +RUN mkdir -p /tmp/scripts +COPY run /tmp/scripts/ +RUN mkdir -p /tmp/scripts/utilities +COPY utilities/holohub_autocomplete /tmp/scripts/utilities/ +RUN chmod +x /tmp/scripts/run +RUN /tmp/scripts/run setup + +# Enable autocomplete +RUN echo ". /etc/bash_completion.d/holohub_autocomplete" >> /etc/bash.bashrc + +# - This variable is consumed by all dependencies below as an environment variable (CMake 3.22+) +# - We use ARG to only set it at docker build time, so it does not affect cmake builds +# performed at docker run time in case users want to use a different BUILD_TYPE +ARG CMAKE_BUILD_TYPE=Release + + +# For benchmarking +RUN apt update \ + && apt install --no-install-recommends -y \ + libcairo2-dev \ + libgirepository1.0-dev \ + gobject-introspection \ + libgtk-3-dev \ + libcanberra-gtk-module \ + graphviz +RUN if ! grep -q "VERSION_ID=\"22.04\"" /etc/os-release; then \ + pip install setuptools; \ + fi +COPY applications/imaging_ai_segmentator/requirements.txt /tmp/requirements.txt +RUN pip install -r /tmp/requirements.txt + +RUN pip install gdown && \ + mkdir -p ${HOLOSCAN_MODEL_PATH} && \ + python -m gdown https://drive.google.com/uc?id=1PHpFWboimEXmMSe2vBra6T8SaCMC2SHT -O ${HOLOSCAN_MODEL_PATH}/model.pt + +RUN mkdir -p ${HOLOSCAN_OUTPUT_PATH} \ No newline at end of file diff --git a/applications/monai_bundle_deployment/README.md b/applications/monai_bundle_deployment/README.md new file mode 100644 index 000000000..126549584 --- /dev/null +++ b/applications/monai_bundle_deployment/README.md @@ -0,0 +1,198 @@ +# AI Segmentation using MONAI re-trained TotalSegmentator model and CT DICOM images as input + +This application uses MONAI re-trained TotalSegmentator model to segment 104 body parts from a DICOM series of a CT scan. It is implemented using Holohub DICOM processing operators and PyTorch inference operators. + +The input is a DICOM CT Series, and the segmentation results are saved as DICOM Segmentation in Part10 storage format, as well as in NIfTI format. The workflow is summarized below, +- load DICOM studies +- select series with application defined rules +- convert DICOM pixel data to 3D volume image +- use MONAI SDK to transform input/output and perform inference +- write results as DICOM Segmentation OID instance, re-using study level metadata from the original DICOM study so that the new instance and series can be associated with the original study + +The following is the screenshot of the 3D volume rendering of the segmentation results in NIfTI format. + +isolated + +The following is the screenshot of a slice of the segmentation saved in DICOM segmentation instance (without color coding the segments). + +isolated + +## Requirements + +- On a [Holohub supported platform](../../README.md#supported-platforms) +- Python 3.8+ +- Python packages on [Pypi](https://pypi.org), including but not limited to torch, monai, nibabel, pydicom, highdicom, and others as specified in the requirements file +- Nvidia GPU with at least 14GB memory, for a 200 slice CT series + + +## Model + +This application uses the [MONAI whole-body segmentation model](https://github.com/Project-MONAI/model-zoo/tree/dev/models/wholeBody_ct_segmentation). + +## Data + +The input for this application is a folder of DICOM image files from a CT series. For testing, CT scan images can be downloaded from [The Cancer Imaging Archive](https://nbia.cancerimagingarchive.net/nbia-search/), subject to [Data Usage Policies and Restrictions](https://www.cancerimagingarchive.net/data-usage-policies-and-restrictions/) + +One such data set, a CT Abdomen series described as `ABD/PANC_3.0_B31f`, was used in testing the application. Other DICOM CT Abdomen series can be downloaded from TCIA as test inputs, and, of course, users' own DICOM seriese shall equally work. + +**_Note_**: +Please download, or otherwise make available, DICOM files of a CT Abdomen series and save them in a folder, preferably named `data/imaging_ai_segmentator/dicom` under the project root, as this folder name is used in the examples in the following steps. Manual download scripts are shown in [`Run the Application in Dev Environment`](#run-the-application-in-dev-environment) + +### Data Citation + +National Cancer Institute Clinical Proteomic Tumor Analysis Consortium (CPTAC). (2018). The Clinical Proteomic Tumor Analysis Consortium Cutaneous Melanoma Collection (CPTAC-CM) (Version 11) [Dataset]. The Cancer Imaging Archive. https://doi.org/10.7937/K9/TCIA.2018.ODU24GZE + + +## Run Instructions + +There are a number of ways to build and run this application, as well as packaging this application as a Holoscan Application Package. The following sections describe each in detail. + +### Quick Start Using Holohub Container + +This is the simplest and fastest way to see the application in action running as a container. The input DICOM files must first be downloaded and saved in the folder `$PWD/data/imaging_ai_segmentator/dicom`, whereas the PyTorch model is automatically downloaded when container image is built. + +Use the following to build and run the application: + +```bash +mkdir -p output +rm -rf output/* +./dev_container build_and_run imaging_ai_segmentator --container_args "-v $PWD/output:/var/holoscan/output -v $PWD/data/imaging_ai_segmentator/dicom:/var/holoscan/input" +``` + +Once the command completes, please check the output folder for the results, e.g. +``` +output +├── 1.2.826.0.1.3680043.10.511.3.57591117750107235783166330094310669.dcm +└── saved_images_folder + └── 1.3.6.1.4.1.14519.5.2.1.7085.2626 + ├── 1.3.6.1.4.1.14519.5.2.1.7085.2626.nii + └── 1.3.6.1.4.1.14519.5.2.1.7085.2626_seg.nii + +2 directories, 3 files +``` + +**_Note_** +It takes quite a few minutes when this command is run the first time. + +### Run the Application in Dev Environment + +It is strongly recommended a Python virtual environment is used for running the application in dev environment. + +This application only has Python implementation depending on a set of Python packages from [Pypi](https://pypi.org), however, a `build_and_install` step is needed to automate organizing Python code and downloading the model. + + +Set up the Holohub environment, if not already done +```bash +./run setup +``` + +Set the environment variables for the application +```bash +source applications/imaging_ai_segmentator/env_settings.sh +``` + +If not already done, download images of a CT series from [TCIA](https://nbia.cancerimagingarchive.net/nbia-search/), unzip if necessary, and save the folder of DICOM files under the folder `$HOLOSCAN_INPUT_PATH`. + +Optionally download the AI model from [MONAI Model Zoo](https://github.com/Project-MONAI/model-zoo/tree/dev/models/wholeBody_ct_segmentation), or wait till the build step to have it downloaded automatically + +```bash +mkdir -p $HOLOSCAN_MODEL_PATH +pip install gdown +python -m gdown https://drive.google.com/uc?id=1PHpFWboimEXmMSe2vBra6T8SaCMC2SHT -O $HOLOSCAN_MODEL_PATH/model.pt +``` + +Install Python packages required by the application +```bash +pip install -r applications/imaging_ai_segmentator/requirements.txt +``` + +Build and install the application +```bash +./dev_container build_and_install imaging_ai_segmentator +``` + +Run the application +```bash +rm -f -r $HOLOSCAN_OUTPUT_PATH +python install/imaging_ai_segmentator/app.py +``` + +**_Note_** +If desired, run the application with explicitly input, output, and/or model folder path, for example +```bash +rm -f -r ./output +python install/imaging_ai_segmentator/app.py -m $HOLOSCAN_MODEL_PATH -i $HOLOSCAN_INPUT_PATH -o ./output +``` + +Check output +```bash +ls $HOLOSCAN_OUTPUT_PATH +``` + +There should be a DICOM segmentation file with randomized file name. There should also a `saved_images_folder` containing folder named after the input DICOM series' instance UID, which in turn contains the input and segmentation image files in NIfTI format, e.g. +```bash +applications/imaging_ai_segmentator/output +├── 1.2.826.0.1.3680043.10.511.3.64271669147396658491950188504278234.dcm +└── saved_images_folder + └── 1.3.6.1.4.1.14519.5.2.1.7085.2626 + ├── 1.3.6.1.4.1.14519.5.2.1.7085.2626.nii + └── 1.3.6.1.4.1.14519.5.2.1.7085.2626_seg.nii +``` + +### Run the Application in Dev Container + +In this mode, there is no need to `build` and `install`. The Python code will run in its source folders, and both the model and input DICOM files need to be downloaded manually with the scripts provided below. + +Also, the `PYTHONPATH` environment variable must be set to locate the necessary Holohub medical imaging operators. The AI model and input DICOM file paths need defined via environment variables, namely `HOLOSCAN_MODEL_PATH` and `HOLOSCAN_INPUT_PATH` respectively, otherwise they must be provided explicitly as command options. + + +First [Build and launch the Holohub Container](../../README.md#container-build-recommended), landing in `/workspace/holohub` + +Set the `PYTHONPATH` to include the Holohub source folder +```bash +export PYTHONPATH=$PYTHONPATH:$PWD +``` + +Set the environment variables for the application +```bash +source applications/imaging_ai_segmentator/env_settings.sh +``` + +If not already done, download images of a CT series from [TCIA](https://nbia.cancerimagingarchive.net/nbia-search/), unzip if necessary, and save the folder of DICOM files under the folder `$HOLOSCAN_INPUT_PATH`. + +Optionally download the AI model from [MONAI Model Zoo](https://github.com/Project-MONAI/model-zoo/tree/dev/models/wholeBody_ct_segmentation), or wait till the build step to have it downloaded automatically + +```bash +mkdir -p $HOLOSCAN_MODEL_PATH +pip install gdown +python -m gdown https://drive.google.com/uc?id=1PHpFWboimEXmMSe2vBra6T8SaCMC2SHT -O $HOLOSCAN_MODEL_PATH/model.pt +``` + +Install Python packages required by the application +```bash +pip install -r applications/imaging_ai_segmentator/requirements.txt +``` +Run the application +```bash +rm -f -r $HOLOSCAN_OUTPUT_PATH +python applications/imaging_ai_segmentator/ +``` + +Check output +```bash +ls $HOLOSCAN_OUTPUT_PATH +``` + +## Packaging the Application for Distribution + +With Holoscan CLI, an applications built with Holoscan SDK can be packaged into a Holoscan Application Package (HAP), which is essentially a Open Container Initiative compliant container image. An HAP is well suited to be distributed for deployment on hosting platforms, be a Docker Compose, Kubernetes, or else. Please refer to [Packaging Holoscan Applications](https://docs.nvidia.com/holoscan/sdk-user-guide/holoscan_packager.html) in the User Guide for more information. + +This example application provides all the necessary contents for HAP packaging, and the specific commands are revealed by the specific commands. + +**_Note_** + +The prerequisite is that the application `build_and_install` has been performed to stage the source and AI model files for packaging. + +``` +source applications/imaging_ai_segmentator/packageHAP.sh +``` diff --git a/applications/monai_bundle_deployment/__main__.py b/applications/monai_bundle_deployment/__main__.py new file mode 100644 index 000000000..d2d497714 --- /dev/null +++ b/applications/monai_bundle_deployment/__main__.py @@ -0,0 +1,27 @@ +#!/usr/bin/env python3 + +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# 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 logging + +from app import AISegApp + +if __name__ == "__main__": + logging.info(f"Begin {__name__}") + + AISegApp().run() + + logging.info(f"End {__name__}") diff --git a/applications/monai_bundle_deployment/app.py b/applications/monai_bundle_deployment/app.py new file mode 100644 index 000000000..54f7042d8 --- /dev/null +++ b/applications/monai_bundle_deployment/app.py @@ -0,0 +1,282 @@ +#!/usr/bin/env python3 + +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# 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 logging +from pathlib import Path + +from holoscan.conditions import CountCondition +from holoscan.core import Application +from monai_totalseg_operator import MonaiTotalSegOperator +from pydicom.sr.codedict import codes # Required for setting SegmentDescription attributes. + +from operators.medical_imaging.core.app_context import AppContext +from operators.medical_imaging.operators.dicom_data_loader_operator import DICOMDataLoaderOperator +from operators.medical_imaging.operators.dicom_seg_writer_operator import ( + DICOMSegmentationWriterOperator, + SegmentDescription, +) +from operators.medical_imaging.operators.dicom_series_selector_operator import ( + DICOMSeriesSelectorOperator, +) +from operators.medical_imaging.operators.dicom_series_to_volume_operator import ( + DICOMSeriesToVolumeOperator, +) + +# Labels for the channels/segments +CHANNEL_DEF = { + "0": "background", + "1": "spleen", + "2": "kidney_right", + "3": "kidney_left", + "4": "gallbladder", + "5": "liver", + "6": "stomach", + "7": "aorta", + "8": "inferior_vena_cava", + "9": "portal_vein_and_splenic_vein", + "10": "pancreas", + "11": "adrenal_gland_right", + "12": "adrenal_gland_left", + "13": "lung_upper_lobe_left", + "14": "lung_lower_lobe_left", + "15": "lung_upper_lobe_right", + "16": "lung_middle_lobe_right", + "17": "lung_lower_lobe_right", + "18": "vertebrae_L5", + "19": "vertebrae_L4", + "20": "vertebrae_L3", + "21": "vertebrae_L2", + "22": "vertebrae_L1", + "23": "vertebrae_T12", + "24": "vertebrae_T11", + "25": "vertebrae_T10", + "26": "vertebrae_T9", + "27": "vertebrae_T8", + "28": "vertebrae_T7", + "29": "vertebrae_T6", + "30": "vertebrae_T5", + "31": "vertebrae_T4", + "32": "vertebrae_T3", + "33": "vertebrae_T2", + "34": "vertebrae_T1", + "35": "vertebrae_C7", + "36": "vertebrae_C6", + "37": "vertebrae_C5", + "38": "vertebrae_C4", + "39": "vertebrae_C3", + "40": "vertebrae_C2", + "41": "vertebrae_C1", + "42": "esophagus", + "43": "trachea", + "44": "heart_myocardium", + "45": "heart_atrium_left", + "46": "heart_ventricle_left", + "47": "heart_atrium_right", + "48": "heart_ventricle_right", + "49": "pulmonary_artery", + "50": "brain", + "51": "iliac_artery_left", + "52": "iliac_artery_right", + "53": "iliac_vena_left", + "54": "iliac_vena_right", + "55": "small_bowel", + "56": "duodenum", + "57": "colon", + "58": "rib_left_1", + "59": "rib_left_2", + "60": "rib_left_3", + "61": "rib_left_4", + "62": "rib_left_5", + "63": "rib_left_6", + "64": "rib_left_7", + "65": "rib_left_8", + "66": "rib_left_9", + "67": "rib_left_10", + "68": "rib_left_11", + "69": "rib_left_12", + "70": "rib_right_1", + "71": "rib_right_2", + "72": "rib_right_3", + "73": "rib_right_4", + "74": "rib_right_5", + "75": "rib_right_6", + "76": "rib_right_7", + "77": "rib_right_8", + "78": "rib_right_9", + "79": "rib_right_10", + "80": "rib_right_11", + "81": "rib_right_12", + "82": "humerus_left", + "83": "humerus_right", + "84": "scapula_left", + "85": "scapula_right", + "86": "clavicula_left", + "87": "clavicula_right", + "88": "femur_left", + "89": "femur_right", + "90": "hip_left", + "91": "hip_right", + "92": "sacrum", + "93": "face", + "94": "gluteus_maximus_left", + "95": "gluteus_maximus_right", + "96": "gluteus_medius_left", + "97": "gluteus_medius_right", + "98": "gluteus_minimus_left", + "99": "gluteus_minimus_right", + "100": "autochthon_left", + "101": "autochthon_right", + "102": "iliopsoas_left", + "103": "iliopsoas_right", + "104": "urinary_bladder", +} + + +class AISegApp(Application): + def __init__(self, *args, **kwargs): + """Creates an application instance.""" + + super().__init__(*args, **kwargs) + self._logger = logging.getLogger("{}.{}".format(__name__, type(self).__name__)) + + def run(self, *args, **kwargs): + # This method calls the base class to run. Can be omitted if simply calling through. + self._logger.info(f"Begin {self.run.__name__}") + super().run(*args, **kwargs) + self._logger.info(f"End {self.run.__name__}") + + def compose(self): + """Creates the app specific operators and chain them up in the processing DAG.""" + + # Use Commandline options over environment variables to init context. + app_context: AppContext = Application.init_app_context(self.argv) + self._logger.debug(f"Begin {self.compose.__name__}") + app_input_path = Path(app_context.input_path) + app_output_path = Path(app_context.output_path).resolve() + model_path = Path(app_context.model_path) + + self._logger.info(f"App input and output path: {app_input_path}, {app_output_path}") + + # The following uses an alternative loader to load dcm from disk + 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") + + # Model specific inference operator, supporting MONAI transforms. + seg_op = MonaiTotalSegOperator( + self, + app_context=app_context, + output_folder=app_output_path / "saved_images_folder", + model_path=model_path, + name="seg_op", + ) + + # https://dicom.nema.org/medical/dicom/current/output/chtml/part05/sect_6.2.html + # User can Look up SNOMED CT codes at, e.g. + # https://bioportal.bioontology.org/ontologies/SNOMEDCT + + _algorithm_name = "3D segmentation from a CT series" + _algorithm_family = codes.DCM.ArtificialIntelligence + _algorithm_version = "0.1.0" + + # To simplify, only use Organ as the dummy category and type, though the body part + # names will be correct. + segment_descriptions = [] + for i in range(1, 105): # seg 1 to 104 + segment_descriptions.append( + SegmentDescription( + segment_label=CHANNEL_DEF.get(str(i), "unknown"), + segmented_property_category=codes.SCT.Organ, + segmented_property_type=codes.SCT.Organ, + algorithm_name=_algorithm_name, + algorithm_family=_algorithm_family, + algorithm_version=_algorithm_version, + ) + ) + + custom_tags = {"SeriesDescription": "AI generated Seg, not for clinical use."} + + dicom_seg_writer = DICOMSegmentationWriterOperator( + self, + segment_descriptions=segment_descriptions, + custom_tags=custom_tags, + output_folder=app_output_path, + name="dcm_seg_writer_op", + ) + + 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")}, + ) + self.add_flow(series_to_vol_op, seg_op, {("image", "image")}) + + # Note below the dicom_seg_writer requires two inputs, each coming from a source operator. + # Seg writing needs all segment descriptions coded, otherwise fails. + self.add_flow( + series_selector_op, + dicom_seg_writer, + {("study_selected_series_list", "study_selected_series_list")}, + ) + self.add_flow(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. +# For list of string values, e.g. "ImageType": ["PRIMARY", "ORIGINAL"], it is a match if all elements +# are all in the multi-value attribute of the DICOM series. + +Sample_Rules_Text = """ +{ + "selections": [ + { + "name": "CT Series", + "conditions": { + "StudyDescription": "(.*?)", + "Modality": "(?i)CT", + "SeriesDescription": "(.*?)", + "ImageType": ["PRIMARY", "ORIGINAL"] + } + } + ] +} +""" + +if __name__ == "__main__": + # Creates the app and test it standalone. When running is this mode, please note the following: + # -m , for model file path + # -i , for input DICOM CT series folder + # -o , for the output folder, default $PWD/output + # e.g. + # python3 app.py -i input -m model/model.ts + # + logging.info(f"Begin {__name__}") + + AISegApp().run() + + logging.info(f"End {__name__}") diff --git a/applications/monai_bundle_deployment/app.yaml b/applications/monai_bundle_deployment/app.yaml new file mode 100644 index 000000000..52151dae6 --- /dev/null +++ b/applications/monai_bundle_deployment/app.yaml @@ -0,0 +1,29 @@ +%YAML 1.2 +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# 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. +--- +# Required fields for packaging the application +# See https://docs.nvidia.com/holoscan/sdk-user-guide/cli/run_config.html# +application: + title: Holoscan App Package - Whole-body segmentation with MONAI re-trained TotalSegmentator + version: 1.0 + inputFormats: ["file"] + outputFormats: ["file"] + +resources: + cpu: 4 + gpu: 1 + memory: 4Gi + gpuMemory: 14Gi diff --git a/applications/monai_bundle_deployment/env_settings.sh b/applications/monai_bundle_deployment/env_settings.sh new file mode 100755 index 000000000..d909bc4ec --- /dev/null +++ b/applications/monai_bundle_deployment/env_settings.sh @@ -0,0 +1,6 @@ +#!/bin/bash +GIT_ROOT=$(readlink -f ./$(git rev-parse --show-cdup)) +export HOLOSCAN_INPUT_PATH="$GIT_ROOT/data/imaging_ai_segmentator/dicom" +export HOLOSCAN_MODEL_PATH="$GIT_ROOT/data/imaging_ai_segmentator/models" +export HOLOSCAN_OUTPUT_PATH="$GIT_ROOT/output" +export HOLOSCAN_LOG_LEVEL=TRACE \ No newline at end of file diff --git a/applications/monai_bundle_deployment/metadata.json b/applications/monai_bundle_deployment/metadata.json new file mode 100644 index 000000000..84fb6a787 --- /dev/null +++ b/applications/monai_bundle_deployment/metadata.json @@ -0,0 +1,88 @@ +{ + "application": { + "name": "Imaging AI Whole Body Segmentation", + "authors": [ + { + "name": "Ming Qin", + "affiliation": "NVIDIA" + } + ], + "language": "Python", + "version": "1.0.0", + "changelog": { + "1.0": "Initial Release" + }, + "holoscan_sdk": { + "minimum_required_version": "2.3.0", + "tested_versions": [ + "2.3.0" + ] + }, + "platforms": [ + "amd64", + "arm64" + ], + "tags": [ + "Radiology Imaging", + "DICOM", + "DICOM SEG", + "Segmentation by AI", + "Total segmentator", + "MONAI", + "MONAI Model Zoo" + ], + "ranking": 1, + "dependencies": { + "python-packages": { + "holoscan": { + "version": "2.3.0", + "license-url": "https://github.com/nvidia-holoscan/holoscan-sdk/blob/main/LICENSE.txt" + }, + "highdicom": { + "version": "0.18.2", + "license-url": "https://github.com/ImagingDataCommons/highdicom/blob/master/LICENSE" + }, + "monai": { + "version": "1.0.0", + "license-url": "https://github.com/Project-MONAI/MONAI/blob/dev/LICENSE" + }, + "nibabel": { + "version": "3.2.1", + "license-url": "https://nipy.org/nibabel/legal.html" + }, + "numpy": { + "version": "1.21.6", + "license-url": "https://github.com/numpy/numpy/blob/main/LICENSE.txt" + }, + "Pillow": { + "version": "8.0.0", + "license-url": "https://github.com/python-pillow/Pillow/blob/main/LICENSE" + }, + "pydicom": { + "version": "2.3.0", + "license-url": "https://github.com/pydicom/pydicom/blob/main/LICENSE" + }, + "SimpleITK": { + "version": "2.0.0", + "license-url": "https://github.com/SimpleITK/SimpleITK/blob/master/LICENSE" + }, + "scikit-image": { + "version": "0.17.2", + "license-url": "https://github.com/scikit-image/scikit-image/blob/main/LICENSE.txt" + }, + "torch": { + "version": "1.2.0", + "license-url": "https://github.com/pytorch/pytorch/blob/main/LICENSE" + }, + "typeguard": { + "version": "3.0.0", + "license-url": "https://github.com/agronholm/typeguard/blob/master/LICENSE" + } + } + }, + "run": { + "command": "python3 /app.py", + "workdir": "holohub_bin" + } + } +} diff --git a/applications/monai_bundle_deployment/monai_bundle_operator.py b/applications/monai_bundle_deployment/monai_bundle_operator.py new file mode 100644 index 000000000..8efaad284 --- /dev/null +++ b/applications/monai_bundle_deployment/monai_bundle_operator.py @@ -0,0 +1,228 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# 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 logging +import os +from collections.abc import Hashable, Mapping +from pathlib import Path +from typing import Dict, Sequence, Union + +import monai +import torch +import glob +from holoscan.core import ConditionType, Fragment, Operator, OperatorSpec +from monai.config import KeysCollection, NdarrayTensor +from monai.bundle import create_workflow +from monai.networks.layers import GaussianFilter +from monai.transforms import ( + Activationsd, + AsDiscreted, + Compose, + EnsureChannelFirstd, + EnsureTyped, + Invertd, + LoadImaged, + MapTransform, + NormalizeIntensityd, + Orientationd, + SaveImaged, + ScaleIntensityd, + Spacingd, +) +from numpy import uint8 + +from operators.medical_imaging.core import AppContext, Model +from operators.medical_imaging.operators.monai_seg_inference_operator import ( + InfererType, + InMemImageReader, + MonaiSegInferenceOperator, +) + + +# from https://github.com/Project-MONAI/MONAI/issues/3178 +class Antialiasingd(MapTransform): + def __init__( + self, + keys: KeysCollection, + sigma: Union[Sequence[float], float] = 1.0, + approx: str = "erf", + threshold: float = 0.5, + allow_missing_keys: bool = False, + ) -> None: + super().__init__(keys, allow_missing_keys) + self.sigma = sigma + self.approx = approx + self.threshold = threshold + + def __call__(self, data: Mapping[Hashable, NdarrayTensor]) -> Dict[Hashable, NdarrayTensor]: + d = dict(data) + for key in self.key_iterator(d): + img = d[key] + + gaussian_filter = GaussianFilter(img.ndim - 1, self.sigma, approx=self.approx) + + labels = torch.unique(img)[1:] + new_img = torch.zeros_like(img) + for label in labels: + label_mask = (img == label).to(torch.float) + blurred = gaussian_filter(label_mask.unsqueeze(0)).squeeze(0) + new_img[blurred > self.threshold] = label + d[key] = new_img + return d + + +class MonaiBundleOperator(Operator): + """Performs MONAI bundle based image inference with a given input image converted from DICOM slices. + + 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. + """ + + DEFAULT_OUTPUT_FOLDER = Path.cwd() / "output/saved_images_folder" + + def __init__( + self, + fragment: Fragment, + *args, + app_context: AppContext, + bundle_path: Path, + output_folder: Path = DEFAULT_OUTPUT_FOLDER, + **kwargs, + ): + self._logger = logging.getLogger("{}.{}".format(__name__, type(self).__name__)) + self._input_dataset_key = "image" + self._pred_dataset_key = "pred" + + self.bundle_path = self.bundle_path + self.output_folder = output_folder + self.output_folder.mkdir(parents=True, exist_ok=True) + self.app_context = app_context + self.input_name_image = "image" + self.output_name_seg = "seg_image" + self.output_name_saved_images_folder = "saved_images_folder" + + # Call the base class __init__() last. + # Also, the base class has an attribute called fragment for storing the fragment object + super().__init__(fragment, *args, **kwargs) + + def setup(self, spec: OperatorSpec): + spec.input(self.input_name_image) + spec.output(self.output_name_seg) + spec.output(self.output_name_saved_images_folder).condition( + ConditionType.NONE + ) # Output not requiring a receiver + + def _get_inference_config(self): + config_files = glob.glob(os.path.join(self.bundle_path, "configs", "inference.*")) + return config_files[0] if config_files else None + + 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.") + + # This operator gets an in-memory Image object, so a specialized ImageReader is needed. + _reader = InMemImageReader(input_image) + + # In this example, the input image, once loaded at the beginning of the pre-transforms, can + # be saved on disk, so can the segmentation prediction image at the end of the post-transform. + # They are both saved in the same subfolder of the application output folder, with names + # distinguished by the postfix. They can also be saved in different subfolder if need be. + # These images files can then be packaged for rendering. + # In the code below, saving of the image files are disabled to save 10 seconds if nii, and 20 if nii.gz + pre_transforms = self.pre_process(_reader, str(self.output_folder)) + post_transforms = self.post_process(pre_transforms, str(self.output_folder)) + + inference_config_file = self._get_inference_config() + workflow = create_workflow(workflow_type="inference", config_file=inference_config_file) + workflow.dataset_dir = input_image + save_path = workflow.save_path + workflow.initialize() + workflow.run() + workflow.finalize() + + # Now emit data to the output ports of this operator + op_output.emit(save_path, self.output_name_seg) + self._logger.debug( + f"Setting {self.output_name_saved_images_folder} with {self.output_folder}" + ) + op_output.emit(self.output_folder, self.output_name_saved_images_folder) + + def pre_process(self, img_reader, out_dir: str = "./input_images") -> Compose: + """Composes transforms for preprocessing input before predicting on a model.""" + + Path(out_dir).mkdir(parents=True, exist_ok=True) + + my_key = self._input_dataset_key + return Compose( + [ + LoadImaged(keys=my_key, reader=img_reader), + EnsureTyped(keys=my_key), + EnsureChannelFirstd(keys=my_key), + Orientationd(keys=my_key, axcodes="RAS"), + # The SaveImaged transform can be commented out to save 5 seconds. + # Uncompress NIfTI file, nii, is used favoring speed over size, but can be changed to nii.gz + SaveImaged( + keys=my_key, + output_dir=out_dir, + output_postfix="", + resample=False, + output_ext=".nii", + ), + Spacingd(keys=my_key, pixdim=(1.5, 1.5, 1.5), mode=("bilinear")), + NormalizeIntensityd(keys=my_key, nonzero=True), + ScaleIntensityd(keys=my_key, minv=-1.0, maxv=1.0), + ] + ) + + def post_process( + self, pre_transforms: Compose, out_dir: str = "./prediction_output" + ) -> Compose: + """Composes transforms for postprocessing the prediction results.""" + + Path(out_dir).mkdir(parents=True, exist_ok=True) + + pred_key = self._pred_dataset_key + return Compose( + [ + Activationsd(keys=pred_key, softmax=True), + AsDiscreted(keys=pred_key, argmax=True), + Invertd( + keys=pred_key, + transform=pre_transforms, + orig_keys=self._input_dataset_key, + nearest_interp=True, + to_tensor=True, + ), + # Smoothen segmentation volume + Antialiasingd( + keys=pred_key, + ), + # The SaveImaged transform can be commented out to save 5 seconds. + # Uncompress NIfTI file, nii, is used favoring speed over size, but can be changed to nii.gz + SaveImaged( + keys=pred_key, + output_dir=out_dir, + output_postfix="seg", + output_dtype=uint8, + resample=False, + output_ext=".nii", + ), + ] + ) diff --git a/applications/monai_bundle_deployment/monai_totalseg_operator.py b/applications/monai_bundle_deployment/monai_totalseg_operator.py new file mode 100644 index 000000000..bec6e22a3 --- /dev/null +++ b/applications/monai_bundle_deployment/monai_totalseg_operator.py @@ -0,0 +1,283 @@ +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# 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 logging +from collections.abc import Hashable, Mapping +from pathlib import Path +from typing import Dict, Sequence, Union + +import monai +import torch +from holoscan.core import ConditionType, Fragment, Operator, OperatorSpec +from monai.config import KeysCollection, NdarrayTensor +from monai.networks.layers import GaussianFilter +from monai.transforms import ( + Activationsd, + AsDiscreted, + Compose, + EnsureChannelFirstd, + EnsureTyped, + Invertd, + LoadImaged, + MapTransform, + NormalizeIntensityd, + Orientationd, + SaveImaged, + ScaleIntensityd, + Spacingd, +) +from numpy import uint8 + +from operators.medical_imaging.core import AppContext, Model +from operators.medical_imaging.operators.monai_seg_inference_operator import ( + InfererType, + InMemImageReader, + MonaiSegInferenceOperator, +) + + +# from https://github.com/Project-MONAI/MONAI/issues/3178 +class Antialiasingd(MapTransform): + def __init__( + self, + keys: KeysCollection, + sigma: Union[Sequence[float], float] = 1.0, + approx: str = "erf", + threshold: float = 0.5, + allow_missing_keys: bool = False, + ) -> None: + super().__init__(keys, allow_missing_keys) + self.sigma = sigma + self.approx = approx + self.threshold = threshold + + def __call__(self, data: Mapping[Hashable, NdarrayTensor]) -> Dict[Hashable, NdarrayTensor]: + d = dict(data) + for key in self.key_iterator(d): + img = d[key] + + gaussian_filter = GaussianFilter(img.ndim - 1, self.sigma, approx=self.approx) + + labels = torch.unique(img)[1:] + new_img = torch.zeros_like(img) + for label in labels: + label_mask = (img == label).to(torch.float) + blurred = gaussian_filter(label_mask.unsqueeze(0)).squeeze(0) + new_img[blurred > self.threshold] = label + d[key] = new_img + return d + + +class MonaiTotalSegOperator(Operator): + """Performs liver and tumor segmentation using a DL model with an image converted from a DICOM CT series. + + The model used in this application is from NVIDIA, and includes configurations for both the pre and post + transforms as well as inferer. The MONAI Core transforms are used, as such, these transforms are + simply ported to this operator. + + This operator makes use of the App SDK MonaiSegInferenceOperator in a composition approach. + It creates the pre-transforms as well as post-transforms with MONAI dictionary based transforms. + 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 the 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. + """ + + DEFAULT_OUTPUT_FOLDER = Path.cwd() / "output/saved_images_folder" + + def __init__( + self, + fragment: Fragment, + *args, + app_context: AppContext, + model_path: Path, + output_folder: Path = DEFAULT_OUTPUT_FOLDER, + **kwargs, + ): + self._logger = logging.getLogger("{}.{}".format(__name__, type(self).__name__)) + self._input_dataset_key = "image" + self._pred_dataset_key = "pred" + + self.model_path = self._find_model_file_path(model_path) + self.output_folder = output_folder + self.output_folder.mkdir(parents=True, exist_ok=True) + self.app_context = app_context + self.input_name_image = "image" + self.output_name_seg = "seg_image" + self.output_name_saved_images_folder = "saved_images_folder" + + # Call the base class __init__() last. + # Also, the base class has an attribute called fragment for storing the fragment object + super().__init__(fragment, *args, **kwargs) + + def _find_model_file_path(self, model_path: Path): + # We'd just have to find the first file and return it for now, + # because it is known that in Holoscan App Package, the path is the root models folder + if model_path: + if model_path.is_file(): + return model_path + elif model_path.is_dir(): + for file in model_path.rglob("*"): + if file.is_file(): + return file + + raise ValueError(f"Model file not found in the provided path: {model_path}") + + def setup(self, spec: OperatorSpec): + spec.input(self.input_name_image) + spec.output(self.output_name_seg) + spec.output(self.output_name_saved_images_folder).condition( + ConditionType.NONE + ) # Output not requiring a receiver + + 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.") + + # This operator gets an in-memory Image object, so a specialized ImageReader is needed. + _reader = InMemImageReader(input_image) + + # In this example, the input image, once loaded at the beginning of the pre-transforms, can + # be saved on disk, so can the segmentation prediction image at the end of the post-transform. + # They are both saved in the same subfolder of the application output folder, with names + # distinguished by the postfix. They can also be saved in different subfolder if need be. + # These images files can then be packaged for rendering. + # In the code below, saving of the image files are disabled to save 10 seconds if nii, and 20 if nii.gz + pre_transforms = self.pre_process(_reader, str(self.output_folder)) + post_transforms = self.post_process(pre_transforms, str(self.output_folder)) + + # Load the PyTorch model directly as the model factory limits the support to TorchScript as of now + + _device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + _blocks_down: tuple = (1, 2, 2, 4) + _blocks_up: tuple = (1, 1, 1) + + # Create the model and push to device + model = monai.networks.nets.segresnet.SegResNet( + spatial_dims=3, + in_channels=1, + out_channels=105, + init_filters=32, + blocks_down=_blocks_down, + blocks_up=_blocks_up, + dropout_prob=0.2, + ).to(_device) + + model.load_state_dict(torch.load(self.model_path)) + model.eval() + + loaded_model = Model(self.model_path, name="monai_total_seg") + loaded_model.predictor = model + + self.app_context.models = loaded_model + # Delegates inference and saving output to the built-in operator. + infer_operator = MonaiSegInferenceOperator( + self.fragment, + roi_size=( + 96, + 96, + 96, + ), + pre_transforms=pre_transforms, + post_transforms=post_transforms, + overlap=0.25, + app_context=self.app_context, + model_name="", + inferer=InfererType.SLIDING_WINDOW, + sw_batch_size=1, + model_path=self.model_path, + name="monai_seg_inference_op", + ) + + # Setting the keys used in the dictionary based transforms + infer_operator.input_dataset_key = self._input_dataset_key + infer_operator.pred_dataset_key = self._pred_dataset_key + + # Now emit data to the output ports of this operator + op_output.emit(infer_operator.compute_impl(input_image, context), self.output_name_seg) + self._logger.debug( + f"Setting {self.output_name_saved_images_folder} with {self.output_folder}" + ) + op_output.emit(self.output_folder, self.output_name_saved_images_folder) + + def pre_process(self, img_reader, out_dir: str = "./input_images") -> Compose: + """Composes transforms for preprocessing input before predicting on a model.""" + + Path(out_dir).mkdir(parents=True, exist_ok=True) + + my_key = self._input_dataset_key + return Compose( + [ + LoadImaged(keys=my_key, reader=img_reader), + EnsureTyped(keys=my_key), + EnsureChannelFirstd(keys=my_key), + Orientationd(keys=my_key, axcodes="RAS"), + # The SaveImaged transform can be commented out to save 5 seconds. + # Uncompress NIfTI file, nii, is used favoring speed over size, but can be changed to nii.gz + SaveImaged( + keys=my_key, + output_dir=out_dir, + output_postfix="", + resample=False, + output_ext=".nii", + ), + Spacingd(keys=my_key, pixdim=(1.5, 1.5, 1.5), mode=("bilinear")), + NormalizeIntensityd(keys=my_key, nonzero=True), + ScaleIntensityd(keys=my_key, minv=-1.0, maxv=1.0), + ] + ) + + def post_process( + self, pre_transforms: Compose, out_dir: str = "./prediction_output" + ) -> Compose: + """Composes transforms for postprocessing the prediction results.""" + + Path(out_dir).mkdir(parents=True, exist_ok=True) + + pred_key = self._pred_dataset_key + return Compose( + [ + Activationsd(keys=pred_key, softmax=True), + AsDiscreted(keys=pred_key, argmax=True), + Invertd( + keys=pred_key, + transform=pre_transforms, + orig_keys=self._input_dataset_key, + nearest_interp=True, + to_tensor=True, + ), + # Smoothen segmentation volume + Antialiasingd( + keys=pred_key, + ), + # The SaveImaged transform can be commented out to save 5 seconds. + # Uncompress NIfTI file, nii, is used favoring speed over size, but can be changed to nii.gz + SaveImaged( + keys=pred_key, + output_dir=out_dir, + output_postfix="seg", + output_dtype=uint8, + resample=False, + output_ext=".nii", + ), + ] + ) diff --git a/applications/monai_bundle_deployment/packageHAP.sh b/applications/monai_bundle_deployment/packageHAP.sh new file mode 100755 index 000000000..516fc3680 --- /dev/null +++ b/applications/monai_bundle_deployment/packageHAP.sh @@ -0,0 +1,45 @@ +#!/bin/bash +# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# 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. +set -e + +GIT_ROOT=$(readlink -f ./$(git rev-parse --show-cdup)) +APP_PATH="$GIT_ROOT/install/imaging_ai_segmentator" + +. $GIT_ROOT/utilities/bash_utils.sh + +if [ ! -d $APP_PATH ]; then + print_error "Please build the Imaging AI Segmentator application first with the following command:" + print_error "./dev_container build_and_install imaging_ai_segmentator" + exit -1 +fi + +PLATFORM=x64-workstation +GPU=$(get_host_gpu) +if [ $(get_host_arch) == "aarch64" ]; then + PLATFORM=igx-orin-devkit +fi + +echo -e "\nPlease use the Holoscan SDK CLI to package and run the Imaging AI Segmentator application with the following set of commands:" +echo -e "\nGeneral command and options to package an application:" +echo -e "${YELLOW}holoscan package -c $APP_PATH/app.yaml --platform [igx-orin-devkit | jetson-agx-orin-devkit | sbsa, x64-workstation] --platform-config [igpu | dgpu] -t holohub-imaging_ai_segmentator -m $GIT_ROOT/data/imaging_ai_segmentator/models $APP_PATH/ ${NOCOLOR}" +echo -e "\nCommand to package this application:" +echo -e "${YELLOW}holoscan package -c $APP_PATH/app.yaml --platform ${PLATFORM} --platform-config ${GPU} -t holohub-imaging_ai_segmentator -m $GIT_ROOT/data/imaging_ai_segmentator/models $APP_PATH/ ${NOCOLOR}" +echo -e "\nList the newly built application container:" +echo -e "${YELLOW}docker images | grep "holohub-imaging_ai_segmentator" | awk '{print \$1\":\"\$2}' ${NOCOLOR}" +echo -e "\nRun the application container, after creating and cleaning output folder:" +echo -e "${YELLOW}mkdir -p ./output && rm -rf ./output/* ${NOCOLOR}" +echo -e "${YELLOW}holoscan run -r \$(docker images | grep "holohub-imaging_ai_segmentator" | awk '{print \$1\":\"\$2}') -i $GIT_ROOT/data/imaging_ai_segmentator/dicom -o ./output${NOCOLOR}" +echo -e "\n\nRefer to Packaging Holoscan Applications (https://docs.nvidia.com/holoscan/sdk-user-guide/holoscan_packager.html) in the User Guide for more information." diff --git a/applications/monai_bundle_deployment/requirements.txt b/applications/monai_bundle_deployment/requirements.txt new file mode 100644 index 000000000..a73bd9521 --- /dev/null +++ b/applications/monai_bundle_deployment/requirements.txt @@ -0,0 +1,10 @@ +holoscan>=2.3.0 +highdicom>=0.18.2 +monai>=1.0.0 +nibabel>=3.2.1 +Pillow>=8.0.0 +pydicom>=2.3.0 +scikit-image>=0.17.2 +SimpleITK>=2.0.0 +torch>=1.12.0 +typeguard>=3.0.0 diff --git a/applications/monai_bundle_deployment/resources/segments_3D.png b/applications/monai_bundle_deployment/resources/segments_3D.png new file mode 100644 index 0000000000000000000000000000000000000000..b088cf313d7dc0c3e8cdbe161b4f8b7cc003cde6 GIT binary patch literal 204763 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

9c3uK9r;;fBt`O_)5dy=ScRd7XdXY51VAkvURc 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.<-$EGSd!dO=o|h%djJU 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