Bump to newest gradio version

.github/workflows/deploy.yml

@@ -10,11 +10,11 @@ jobs:
   sync-to-hub:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
           lfs: true
       - name: Push to hub
         env:
           HF_TOKEN: ${{ secrets.HF_TOKEN }}
-        run: git push https://andreped:$HF_TOKEN@huggingface.co/spaces/andreped/LyNoS main
+        run: git push https://dbouget:$HF_TOKEN@huggingface.co/spaces/dbouget/LyNoS main

.github/workflows/linting.yml

@@ -11,16 +11,16 @@ on:
 
 jobs:
   build:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v1
+      - uses: actions/checkout@v4
       - name: Set up Python 3.10
-        uses: actions/setup-python@v2
+        uses: actions/setup-python@v5
         with:
           python-version: "3.10"
       
       - name: Install lint dependencies
-        run: pip install wheel setuptools black==22.3.0 isort==5.10.1 flake8==4.0.1
+        run: pip install wheel setuptools black isort flake8
 
       - name: Lint the code
         run: sh shell/lint.sh

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

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
@@ -56,10 +56,10 @@ WORKDIR $HOME/app
 COPY --chown=user . $HOME/app
 
 # Download pretrained models
-RUN wget "https://github.com/raidionics/Raidionics-models/releases/download/1.2.0/Raidionics-CT_LymphNodes-ONNX-v12.zip" && \
-    unzip "Raidionics-CT_LymphNodes-ONNX-v12.zip" && mkdir -p resources/models/ && mv CT_LymphNodes/ resources/models/CT_LymphNodes/
-RUN wget "https://github.com/raidionics/Raidionics-models/releases/download/1.2.0/Raidionics-CT_Lungs-ONNX-v12.zip" && \
-    unzip "Raidionics-CT_Lungs-ONNX-v12.zip" && mv CT_Lungs/ resources/models/CT_Lungs/
+RUN wget "https://github.com/raidionics/Raidionics-models/releases/download/v1.3.0-rc/Raidionics-CT_LymphNodes-v13.zip" && \
+    unzip "Raidionics-CT_LymphNodes-v13.zip" && mkdir -p resources/models/ && mv CT_LymphNodes/ resources/models/CT_LymphNodes/
+RUN wget "https://github.com/raidionics/Raidionics-models/releases/download/v1.3.0-rc/Raidionics-CT_Lungs-v13.zip" && \
+    unzip "Raidionics-CT_Lungs-v13.zip" && mv CT_Lungs/ resources/models/CT_Lungs/
 
 RUN rm -r *.zip
 

demo/requirements.txt

@@ -1,3 +1,2 @@
-raidionicsrads@git+https://github.com/dbouget/raidionics_rads_lib
-gradio@https://gradio-pypi-previews.s3.amazonaws.com/c5d763c3305fc143ace9ca6f8bdc32f12cef74d1/gradio-4.42.0-py3-none-any.whl
-gradio_shinymodel3d@https://github.com/raidionics/LyNoS/releases/download/ShinyModel3D/gradio_shinymodel3d-0.0.1-py3-none-any.whl
+raidionicsrads
+gradio

demo/src/gui.py

@@ -1,7 +1,9 @@
 import os
 
 import gradio as gr
-from gradio_shinymodel3d import ShinyModel3D
+# from gradio_shinymodel3d import ShinyModel3D
+from zipfile import ZipFile
+from PIL import Image
 
 from .convert import nifti_to_obj
 from .css_style import css
@@ -23,36 +25,39 @@ 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 = 820
-
         self.model_name = model_name
         self.cwd = cwd
         self.share = share
 
-        self.class_name = "Lymph Nodes"  # default
+        self.class_name = "LymphNodes"  # default
         self.class_names = {
-            "Lymph Nodes": "CT_LymphNodes",
+            "LymphNodes": "CT_LymphNodes",
         }
 
         self.result_names = {
-            "Lymph Nodes": "LymphNodes",
+            "LymphNodes": "LymphNodes",
         }
 
-        # define widgets not to be rendered immediantly, but later on
-        self.slider = gr.Slider(
-            minimum=1,
-            maximum=self.nb_slider_items,
-            value=1,
-            step=1,
-            label="Which 2D slice to show",
+        self.volume_renderer = gr.Model3D(
+            clear_color=[0.0, 0.0, 0.0, 0.0],
+            label="3D Model",
+            visible=True,
+            elem_id="model-3d",
+            height=512,
         )
-        # self.volume_renderer = gr.Model3D(
-        self.volume_renderer = ShinyModel3D()
+        # self.volume_renderer = ShinyModel3D()
 
     def set_class_name(self, value):
         LOGGER.info(f"Changed task to: {value}")
@@ -83,25 +88,72 @@ class WebUI:
         LOGGER.info("Loading prediction volume to numpy..")
         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)
-        out = gr.AnnotatedImage(
-            self.combine_ct_and_seg(self.images[k], self.pred_images[k]),
-            visible=True,
-            elem_id="model-2d",
-        )
-        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 toggle_sidebar(self, state):
         state = not state
         return gr.update(visible=state), state
 
+    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 setup_interface_outputs(self):
+        with gr.Row():
+            with gr.Group():
+                with gr.Column(scale=2):
+                    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 run(self):
         with gr.Blocks(css=css) as demo:
             with gr.Row():
-                with gr.Column(visible=True, scale=0.2) as sidebar_left:
+                with gr.Column(scale=1, visible=True) as sidebar_left:
                     logs = gr.Textbox(
                         placeholder="\n" * 16,
                         label="Logs",
@@ -115,11 +167,13 @@ class WebUI:
                         container=True,
                         # line_breaks=True,
                     )
-                    demo.load(read_logs, None, logs, every=1)
+                    timer = gr.Timer(value=1, active=True)
+                    timer.tick(fn=read_logs, inputs=None, outputs=logs)
+                    # demo.load(read_logs, None, logs, every=0.5)
 
-                with gr.Column():
+                with gr.Column(scale=2):
                     with gr.Row():
-                        with gr.Column(scale=0.2, min_width=150):
+                        with gr.Column(min_width=150):
                             sidebar_state = gr.State(True)
 
                             btn_toggle_sidebar = gr.Button(
@@ -135,36 +189,25 @@ class WebUI:
                             btn_clear_logs = gr.Button("Clear logs", elem_id="logs-button")
                             btn_clear_logs.click(flush_logs, [], [])
 
-                        file_output = gr.File(file_count="single", elem_id="upload")
-                        file_output.upload(self.upload_file, file_output, file_output)
+                        self.file_output = gr.File(file_count="single", elem_id="upload")
 
-                        model_selector = gr.Dropdown(
+                        self.model_selector = gr.Dropdown(
                             list(self.class_names.keys()),
                             label="Task",
                             info="Which structure to segment.",
                             multiselect=False,
                         )
-                        model_selector.input(
-                            fn=lambda x: self.set_class_name(x),
-                            inputs=model_selector,
-                            outputs=None,
-                        )
 
-                        with gr.Column(scale=0.2, min_width=150):
-                            run_btn = gr.Button("Run analysis", variant="primary", elem_id="run-button")
-                            run_btn.click(
-                                fn=lambda x: self.process(x),
-                                inputs=file_output,
-                                outputs=self.volume_renderer,
-                            )
+                        with gr.Column(min_width=150):
+                            self.run_btn = gr.Button("Run segmentation", variant="primary", elem_id="run-button")
 
                     with gr.Row():
                         gr.Examples(
                             examples=[
                                 os.path.join(self.cwd, "test_thorax_CT.nii.gz"),
                             ],
-                            inputs=file_output,
-                            outputs=file_output,
+                            inputs=self.file_output,
+                            outputs=self.file_output,
                             fn=self.upload_file,
                             cache_examples=False,
                         )
@@ -176,21 +219,17 @@ class WebUI:
                             """
                         )
 
-                    with gr.Row():
-                        with gr.Column():
-                            # create dummy image to be replaced by loaded images
-                            t = gr.AnnotatedImage(visible=True, elem_id="model-2d")
-
-                            self.slider.input(
-                                self.get_img_pred_pair,
-                                self.slider,
-                                t,
-                            )
-
-                            self.slider.render()
-
-                        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],
+                               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/
         # inference times > 60 seconds -> need queue():

demo/src/inference.py

@@ -3,6 +3,8 @@ import logging
 import os
 import shutil
 import traceback
+import json
+import fnmatch
 
 
 def run_model(
@@ -10,7 +12,7 @@ def run_model(
     model_path: str,
     verbose: str = "info",
     task: str = "CT_LymphNodes",
-    name: str = "Lymph nodes",
+    name: str = "LymphNodes",
 ):
     if verbose == "debug":
         logging.getLogger().setLevel(logging.DEBUG)
@@ -55,11 +57,8 @@ 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")
@@ -68,16 +67,41 @@ def run_model(
         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 = [f"*-{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")
+
         # Clean-up
         if os.path.exists(patient_directory):
             shutil.rmtree(patient_directory)