Overall update to match Raidionics v1.3

.github/workflows/deploy.yml

@@ -10,7 +10,7 @@ jobs:
   sync-to-hub:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
           lfs: true

Dockerfile

@@ -1,6 +1,6 @@
 # read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
 # you will also find guides on how best to write your Dockerfile
-FROM python:3.8-slim
+FROM python:3.10-slim
 
 # set language, format and stuff
 ENV LANG=C.UTF-8 LC_ALL=C.UTF-8
@@ -30,7 +30,7 @@ COPY ./requirements.txt /code/requirements.txt
 RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
 
 # resolve issue with tf==2.4 and gradio dependency collision issue
-RUN pip install --force-reinstall typing_extensions==4.7.1
+# RUN pip install --force-reinstall typing_extensions==4.7.1
 
 # Install wget
 RUN apt install wget -y && \
@@ -54,16 +54,8 @@ COPY --chown=user . $HOME/app
 
 # Download pretrained models
 RUN mkdir -p resources/models/
-RUN wget "https://github.com/raidionics/Raidionics-models/releases/download/1.2.0/Raidionics-MRI_Brain-ONNX-v12.zip" && \
-    unzip "Raidionics-MRI_Brain-ONNX-v12.zip" && mv MRI_Brain/ resources/models/MRI_Brain/
-RUN wget "https://github.com/raidionics/Raidionics-models/releases/download/1.2.0/Raidionics-MRI_GBM-ONNX-v12.zip" && \
-    unzip "Raidionics-MRI_GBM-ONNX-v12.zip" && mv MRI_GBM/ resources/models/MRI_GBM/
-RUN wget "https://github.com/raidionics/Raidionics-models/releases/download/1.2.0/Raidionics-MRI_LGGlioma-ONNX-v12.zip" && \
-    unzip "Raidionics-MRI_LGGlioma-ONNX-v12.zip" && mv MRI_LGGlioma/ resources/models/MRI_LGGlioma/
-RUN wget "https://github.com/raidionics/Raidionics-models/releases/download/1.2.0/Raidionics-MRI_Meningioma-ONNX-v12.zip" && \
-    unzip "Raidionics-MRI_Meningioma-ONNX-v12.zip" && mv MRI_Meningioma/ resources/models/MRI_Meningioma/
-RUN wget "https://github.com/raidionics/Raidionics-models/releases/download/1.2.0/Raidionics-MRI_Metastasis-ONNX-v12.zip" && \
-    unzip "Raidionics-MRI_Metastasis-ONNX-v12.zip" && mv MRI_Metastasis/ resources/models/MRI_Metastasis/
+RUN wget "https://github.com/raidionics/Raidionics-models/releases/download/v1.3.0-rc/Raidionics_HF_Neuro_Resources-v13.zip" && \
+    unzip "Raidionics_HF_Neuro_Resources-v13.zip" -d resources/models/
 
 RUN rm -r *.zip
 

requirements.txt

@@ -1,2 +1,2 @@
-raidionicsrads@git+https://github.com/andreped/raidionics_rads_lib
-gradio==3.44.4
+raidionicsrads
+gradio

src/gui.py

@@ -1,6 +1,9 @@
 import os
 
 import gradio as gr
+from PIL import Image
+import logging
+from zipfile import ZipFile
 
 from .inference import run_model
 from .utils import load_pred_volume_to_numpy
@@ -15,50 +18,47 @@ class WebUI:
         cwd: str = "/home/user/app/",
         share: int = 1,
     ):
+        self.file_output = None
+        self.model_selector = None
+        self.stripped_cb = None
+        self.registered_cb = None
+        self.run_btn = None
+        self.slider = None
+        self.download_file = None
+
         # global states
         self.images = []
         self.pred_images = []
-
-        # @TODO: This should be dynamically set based on chosen volume size
-        self.nb_slider_items = 512
+        self.image_boxes = []
 
         self.model_name = model_name
         self.cwd = cwd
         self.share = share
 
-        self.class_name = "meningioma"  # default
+        self.class_name = "tumorcore"  # default
         self.class_names = {
-            "meningioma": "MRI_Meningioma",
-            "lower-grade-glioma": "MRI_LGGlioma",
-            "metastasis": "MRI_Metastasis",
-            "glioblastoma": "MRI_GBM",
+            "tumorcore": "MRI_TumorCore",
+            "NETC": "MRI_Necrosis",
+            "residual-tumor": "MRI_TumorCE_Postop",
+            "cavity": "MRI_Cavity",
             "brain": "MRI_Brain",
         }
 
         self.result_names = {
-            "meningioma": "Tumor",
-            "lower-grade-glioma": "Tumor",
-            "metastasis": "Tumor",
-            "glioblastoma": "Tumor",
+            "tumorcore": "Tumor",
+            "NETC": "NETC",
+            "residual-tumor": "Tumor",
+            "cavity": "Cavity",
             "brain": "Brain",
         }
 
-        # define widgets not to be rendered immediately, but later on
-        self.slider = gr.Slider(
-            minimum=1,
-            maximum=self.nb_slider_items,
-            value=1,
-            step=1,
-            label="Which 2D slice to show",
-            interactive=True,
-        )
-
         self.volume_renderer = gr.Model3D(
             clear_color=[0.0, 0.0, 0.0, 0.0],
             label="3D Model",
             visible=True,
             elem_id="model-3d",
-        ).style(height=512)
+            height=512,
+        )
 
     def set_class_name(self, value):
         print("Changed task to:", value)
@@ -70,35 +70,97 @@ class WebUI:
     def upload_file(self, file):
         return file.name
 
-    def process(self, mesh_file_name):
+    def process(self, mesh_file_name, stripped_inputs_status:bool=False):
         path = mesh_file_name.name
         run_model(
             path,
             model_path=os.path.join(self.cwd, "resources/models/"),
             task=self.class_names[self.class_name],
             name=self.result_names[self.class_name],
+            stripped_inputs_status=stripped_inputs_status,
         )
         nifti_to_glb("prediction.nii.gz")
 
         self.images = load_to_numpy(path)
-        # @TODO. Dynamic update of the slider does not seem to work like this
-        # self.nb_slider_items = len(self.images)
-        # self.slider.update(value=int(self.nb_slider_items/2), maximum=self.nb_slider_items)
 
         self.pred_images = load_pred_volume_to_numpy("./prediction.nii.gz")
-        return "./prediction.obj"
+        slider = gr.Slider(
+            minimum=0,
+            maximum=len(self.images) - 1,
+            value=int(len(self.images) / 2),
+            step=1,
+            label="Which 2D slice to show",
+            interactive=True,
+        )
+
+        return "./prediction.obj", slider
 
     def get_img_pred_pair(self, k):
-        k = int(k) - 1
-        # @TODO. Will the duplicate the last slice to fill up, since slider not adjustable right now
-        if k >= len(self.images):
-            k = len(self.images) - 1
-        out = [gr.AnnotatedImage.update(visible=False)] * self.nb_slider_items
-        out[k] = gr.AnnotatedImage.update(
-            self.combine_ct_and_seg(self.images[k], self.pred_images[k]),
-            visible=True,
-        )
-        return out
+        img = self.images[k]
+        img_pil = Image.fromarray(img)
+        seg_list = []
+        seg_list.append((self.pred_images[k], self.class_name))
+        return img_pil, seg_list
+
+    def setup_interface_inputs(self):
+        with gr.Row():
+            with gr.Column():
+                self.file_output = gr.File(file_count="single", elem_id="upload")
+
+            with gr.Column():
+                self.model_selector = gr.Dropdown(
+                    list(self.class_names.keys()),
+                    label="Segmentation task",
+                    info="Select the segmentation model to run",
+                    multiselect=False,
+                    # size="sm",
+                )
+
+            with gr.Column():
+                with gr.Row():
+                    self.stripped_cb = gr.Checkbox(label="Stripped inputs")
+                    self.registered_cb = gr.Checkbox(label="Co-registered inputs")
+                with gr.Row():
+                    self.run_btn = gr.Button("Run segmentation", scale=1)
+
+    def setup_interface_outputs(self):
+        with gr.Row():
+            with gr.Group():
+                with gr.Column():
+                    t = gr.AnnotatedImage(
+                        visible=True,
+                        elem_id="model-2d",
+                        color_map={self.class_name: "#ffae00"},
+                        height=512,
+                        width=512,
+                    )
+
+                    self.slider = gr.Slider(
+                        minimum=0,
+                        maximum=1,
+                        value=0,
+                        step=1,
+                        label="Which 2D slice to show",
+                        interactive=True,
+                    )
+
+                    self.slider.change(fn=self.get_img_pred_pair, inputs=self.slider, outputs=t)
+
+            with gr.Group():
+                self.volume_renderer.render()
+                self.download_btn = gr.DownloadButton(label="Download results", visible=False)
+                self.download_file = gr.File(label="Download Zip", interactive=True, visible=False)
+
+    def package_results(self):
+        """Generates text files and zips them."""
+        output_dir = "temp_output"
+        os.makedirs(output_dir, exist_ok=True)
+
+        zip_filename = os.path.join(output_dir, "generated_files.zip")
+        with ZipFile(zip_filename, 'w') as zf:
+            zf.write("./prediction.nii.gz")
+
+        return zip_filename
 
     def run(self):
         css = """
@@ -114,66 +176,29 @@ class WebUI:
         }
         """
         with gr.Blocks(css=css) as demo:
-            with gr.Row():
-                file_output = gr.File(file_count="single", elem_id="upload")
-                file_output.upload(self.upload_file, file_output, file_output)
-
-                model_selector = gr.Dropdown(
-                    list(self.class_names.keys()),
-                    label="Segmentation task",
-                    info="Select the preoperative segmentation model to run",
-                    multiselect=False,
-                    size="sm",
-                )
-                model_selector.input(
-                    fn=lambda x: self.set_class_name(x),
-                    inputs=model_selector,
-                    outputs=None,
-                )
-
-                run_btn = gr.Button("Run segmentation").style(
-                    full_width=False, size="lg"
-                )
-                run_btn.click(
-                    fn=lambda x: self.process(x),
-                    inputs=file_output,
-                    outputs=self.volume_renderer,
-                )
-
+            # Define the interface components first
+            self.setup_interface_inputs()
             with gr.Row():
                 gr.Examples(
                     examples=[
                         os.path.join(self.cwd, "t1gd.nii.gz"),
                     ],
-                    inputs=file_output,
-                    outputs=file_output,
+                    inputs=self.file_output,
+                    outputs=self.file_output,
                     fn=self.upload_file,
                     cache_examples=True,
                 )
-
-            with gr.Row():
-                with gr.Box():
-                    with gr.Column():
-                        image_boxes = []
-                        for i in range(self.nb_slider_items):
-                            visibility = True if i == 1 else False
-                            t = gr.AnnotatedImage(
-                                visible=visibility, elem_id="model-2d"
-                            ).style(
-                                color_map={self.class_name: "#ffae00"},
-                                height=512,
-                                width=512,
-                            )
-                            image_boxes.append(t)
-
-                        self.slider.input(
-                            self.get_img_pred_pair, self.slider, image_boxes
-                        )
-
-                        self.slider.render()
-
-                with gr.Box():
-                    self.volume_renderer.render()
+            self.setup_interface_outputs()
+
+            # Define the signals/slots
+            self.file_output.upload(self.upload_file, self.file_output, self.file_output)
+            self.model_selector.input(fn=lambda x: self.set_class_name(x), inputs=self.model_selector, outputs=None)
+            self.run_btn.click(fn=self.process, inputs=[self.file_output, self.stripped_cb],
+                               outputs=[self.volume_renderer, self.slider]).then(fn=lambda:
+            gr.DownloadButton(visible=True), inputs=None, outputs=self.download_btn)
+            self.download_btn.click(fn=self.package_results, inputs=[], outputs=self.download_file).then(fn=lambda
+                file_path: gr.File(label="Download Zip", visible=True, value=file_path), inputs=self.download_file,
+                                    outputs=self.download_file)
 
         # sharing app publicly -> share=True:
         # https://gradio.app/sharing-your-app/

src/inference.py

@@ -2,14 +2,17 @@ import configparser
 import logging
 import os
 import shutil
+import json
+import fnmatch
 
 
 def run_model(
     input_path: str,
     model_path: str,
     verbose: str = "info",
-    task: str = "MRI_Meningioma",
+    task: str = "MRI_TumorCore",
     name: str = "Tumor",
+    stripped_inputs_status: bool = False,
 ):
     logging.basicConfig()
     logging.getLogger().setLevel(logging.WARNING)
@@ -55,38 +58,53 @@ def run_model(
         rads_config.set("System", "input_folder", patient_directory)
         rads_config.set("System", "output_folder", output_path)
         rads_config.set("System", "model_folder", model_path)
-        rads_config.set(
-            "System",
-            "pipeline_filename",
-            os.path.join(model_path, task, "pipeline.json"),
-        )
+        rads_config.set('System', 'pipeline_filename', os.path.join(output_path,
+                                                                    'test_pipeline.json'))
         rads_config.add_section("Runtime")
         rads_config.set(
             "Runtime", "reconstruction_method", "thresholding"
         )  # thresholding, probabilities
         rads_config.set("Runtime", "reconstruction_order", "resample_first")
         rads_config.set("Runtime", "use_preprocessed_data", "False")
+        rads_config.set('Runtime', 'use_stripped_data', 'True' if stripped_inputs_status else 'False')
 
         with open("rads_config.ini", "w") as f:
             rads_config.write(f)
 
+        pip = {}
+        step_index = 1
+        pip_num = str(step_index)
+        pip[pip_num] = {}
+        pip[pip_num]["task"] = "Classification"
+        pip[pip_num]["inputs"] = {}  # Empty input means running it on all existing data for the patient
+        pip[pip_num]["target"] = ["MRSequence"]
+        pip[pip_num]["model"] = "MRI_SequenceClassifier"
+        pip[pip_num]["description"] = "Classification of the MRI sequence type for all input scans."
+
+        step_index = step_index + 1
+        pip_num = str(step_index)
+        pip[pip_num] = {}
+        pip[pip_num]["task"] = 'Model selection'
+        pip[pip_num]["model"] = task
+        pip[pip_num]["timestamp"] = 0
+        pip[pip_num]["format"] = "thresholding"
+        pip[pip_num]["description"] = f"Identifying the best {task} segmentation model for existing inputs"
+
+        with open(os.path.join(output_path, 'test_pipeline.json'), 'w', newline='\n') as outfile:
+            json.dump(pip, outfile, indent=4, sort_keys=True)
+
         # finally, run inference
         from raidionicsrads.compute import run_rads
-
         run_rads(config_filename="rads_config.ini")
 
-        # rename and move final result
-        os.rename(
-            "./result/prediction-"
-            + splits[0]
-            + "/T0/"
-            + splits[0]
-            + "-t1gd_annotation-"
-            + name
-            + ".nii.gz",
-            "./prediction.nii.gz",
-        )
-
+        logging.info(f"Looking for the following pattern: {task}")
+        patterns = ["*_" + task + '.*', "*_" + name + '.*']
+        existing_files = os.listdir(os.path.join(output_path, "T0"))
+        logging.info(f"Existing files: {existing_files}")
+        fileName = str(os.path.join(output_path, "T0",
+                                    [x for x in existing_files if
+                                     any(fnmatch.fnmatch(x, pattern) for pattern in patterns)][0]))
+        os.rename(src=fileName, dst="./prediction.nii.gz")
     except Exception as e:
         print(e)