Added a simple Gradio web demo

.dockerfile

@@ -0,0 +1,8 @@
+venv/
+*.nii
+*.nii.gz
+*.pyc
+*.egg-info
+*.csv
+*__pycache__/
+*.DS_Store

.gitignore

@@ -0,0 +1,15 @@
+venv/
+*.nii
+*.nii.gz
+*.pyc
+*.egg-info
+*.csv
+*.ini
+*__pycache__/
+*.DS_Store
+*.json
+*.onnx
+*.xml
+*.obj
+*.zip
+*.txt

Dockerfile

@@ -0,0 +1,71 @@
+# 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
+
+# set language, format and stuff
+ENV LANG=C.UTF-8 LC_ALL=C.UTF-8
+
+WORKDIR /code
+
+RUN apt-get update -y
+#RUN apt-get install -y python3 python3-pip
+RUN apt install git --fix-missing -y
+RUN apt install wget -y
+
+# installing other libraries
+RUN apt-get install python3-pip -y && \
+    apt-get -y install sudo
+RUN apt-get install curl -y
+RUN apt-get install nano -y
+RUN apt-get update && apt-get install -y git
+RUN apt-get install libblas-dev -y && apt-get install liblapack-dev -y
+RUN apt-get install gfortran -y
+RUN apt-get install libpng-dev -y
+RUN apt-get install python3-dev -y
+
+WORKDIR /code
+
+# install dependencies
+COPY ./demo/requirements.txt /code/demo/requirements.txt
+RUN pip install --no-cache-dir --upgrade -r /code/demo/requirements.txt
+
+# resolve issue with tf==2.4 and gradio dependency collision issue
+RUN pip install --force-reinstall typing_extensions==4.7.1
+
+# lower pydantic version to work with typing_extensions deprecation
+RUN pip install --force-reinstall "pydantic<2.0.0"
+
+# Install wget
+RUN apt install wget -y && \
+    apt install unzip
+
+# Set up a new user named "user" with user ID 1000
+RUN useradd -m -u 1000 user
+
+# Switch to the "user" user
+USER user
+
+# Set home to the user's home directory
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+# Set the working directory to the user's home directory
+WORKDIR $HOME/app
+
+# Copy the current directory contents into the container at $HOME/app setting the owner to the user
+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 rm -r *.zip
+
+# Download test sample
+# @TODO: I have resampled the volume to 1mm isotropic for faster computation
+RUN wget "https://github.com/andreped/neukit/releases/download/test-data/test_thorax_CT.nii.gz"
+
+# CMD ["/bin/bash"]
+CMD ["python3", "demo/app.py"]

demo/README.md

@@ -0,0 +1,27 @@
+# Hugging Face demo - through docker SDK
+
+Deploying simple models in a gradio-based web interface in Hugging Face spaces is easy.
+For any other custom pipeline, with various dependencies and challenging behaviour, it
+might be necessary to use Docker containers instead.
+
+For every new push to the main branch, continuous deployment to the Hugging Face
+`LyNoS` space is performed through a GitHub Actions workflow.
+
+When the space is updated, the Docker image is rebuilt/updated (caching if possible).
+Then when finished, the end users can test the app as they please.
+
+Right now, the functionality of the app is extremely limited, only offering a widget
+for uploading a NIfTI file (`.nii` or `.nii.gz`) and visualizing the produced surface
+of the predicted lung tumor volume when finished processing.
+
+Analysis process can be monitored from the `Logs` tab next to the `Running` button
+in the Hugging Face `LyNoS` space.
+
+It is also possible to build the app as a docker image and deploy it. To do so follow these steps:
+
+```
+docker build -t LyNoS:latest ..
+docker run -it -p 7860:7860 LyNoS:latest
+```
+
+Then open `http://localhost:7860` in your favourite internet browser to view the demo.

demo/app.py

@@ -0,0 +1,43 @@
+import os
+from argparse import ArgumentParser
+
+from src.gui import WebUI
+
+
+def main():
+    parser = ArgumentParser()
+    parser.add_argument(
+        "--cwd",
+        type=str,
+        default="/home/user/app/",
+        help="Set current working directory (path to app.py).",
+    )
+    parser.add_argument(
+        "--share",
+        type=int,
+        default=0,
+        help="Whether to enable the app to be accessible online"
+        "-> setups a public link which requires internet access.",
+    )
+    args = parser.parse_args()
+
+    print("Current working directory:", args.cwd)
+
+    if not os.path.exists(args.cwd):
+        raise ValueError("Chosen 'cwd' is not a valid path!")
+    if args.share not in [0, 1]:
+        raise ValueError(
+            "The 'share' argument can only be set to 0 or 1, but was:",
+            args.share,
+        )
+
+    print("Current cwd:", args.cwd)
+
+    # initialize and run app
+    print("Launching demo...")
+    app = WebUI(cwd=args.cwd, share=args.share)
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

demo/src/convert.py

@@ -0,0 +1,35 @@
+import nibabel as nib
+from nibabel.processing import resample_to_output
+from skimage.measure import marching_cubes
+
+
+def nifti_to_obj(path, output="prediction.obj"):
+    # load NIFTI into numpy array
+    image = nib.load(path)
+    resampled = resample_to_output(image, [1, 1, 1], order=1)
+    data = resampled.get_fdata().astype("uint8")
+
+    # Create a material with a red diffuse color (RGB value)
+    red_material = "newmtl RedMaterial\nKd 1 0 0"  # Red diffuse color (RGB)
+
+    # extract surface
+    verts, faces, normals, values = marching_cubes(data, 0)
+    faces += 1
+
+    with open(output, "w") as thefile:
+        # Write the material definition to the OBJ file
+        thefile.write(red_material + "\n")
+
+        for item in verts:
+            # thefile.write('usemtl RedMaterial\n')
+            thefile.write("v {0} {1} {2}\n".format(item[0], item[1], item[2]))
+
+        for item in normals:
+            thefile.write("vn {0} {1} {2}\n".format(item[0], item[1], item[2]))
+
+        for item in faces:
+            thefile.write(
+                "f {0}//{0} {1}//{1} {2}//{2}\n".format(
+                    item[0], item[1], item[2]
+                )
+            )

demo/src/css_style.py

@@ -0,0 +1,27 @@
+css = """
+#model-3d {
+height: 512px;
+}
+#model-2d {
+height: 512px;
+margin: auto;
+}
+#upload {
+height: 110px;
+}
+#run-button {
+height: 110px;
+width: 150px;
+}
+#toggle-button {
+height: 47px;
+width: 150px;
+}
+#logs-button {
+height: 47px;
+width: 150px;
+}
+#logs {
+height: auto
+}
+"""

demo/src/gui.py

@@ -0,0 +1,231 @@
+import os
+
+import gradio as gr
+
+from .convert import nifti_to_obj
+from .css_style import css
+from .inference import run_model
+from .logger import flush_logs
+from .logger import read_logs
+from .logger import setup_logger
+from .utils import load_ct_to_numpy
+from .utils import load_pred_volume_to_numpy
+
+# setup logging
+LOGGER = setup_logger()
+
+
+class WebUI:
+    def __init__(
+        self,
+        model_name: str = None,
+        cwd: str = "/home/user/app/",
+        share: int = 1,
+    ):
+        # 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_names = {
+            "Lymph Nodes": "CT_LymphNodes",
+        }
+
+        self.result_names = {
+            "Lymph Nodes": "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",
+            show_label=True,
+            visible=True,
+            elem_id="model-3d",
+            camera_position=[90, 180, 768],
+        ).style(height=512)
+
+    def set_class_name(self, value):
+        LOGGER.info(f"Changed task to: {value}")
+        self.class_name = value
+
+    def combine_ct_and_seg(self, img, pred):
+        return (img, [(pred, self.class_name)])
+
+    def upload_file(self, file):
+        out = file.name
+        LOGGER.info(f"File uploaded: {out}")
+        return out
+
+    def process(self, mesh_file_name):
+        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],
+        )
+        LOGGER.info("Converting prediction NIfTI to OBJ...")
+        nifti_to_obj("prediction.nii.gz")
+
+        LOGGER.info("Loading CT to numpy...")
+        self.images = load_ct_to_numpy(path)
+
+        LOGGER.info("Loading prediction volume to numpy..")
+        self.pred_images = load_pred_volume_to_numpy("./prediction.nii.gz")
+
+        return "./prediction.obj"
+
+    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",
+        ).style(
+            color_map={self.class_name: "#ffae00"},
+            height=512,
+            width=512,
+        )
+        return out
+
+    def toggle_sidebar(self, state):
+        state = not state
+        return gr.update(visible=state), state
+
+    def run(self):
+        with gr.Blocks(css=css) as demo:
+            with gr.Row():
+                with gr.Column(visible=True, scale=0.2) as sidebar_left:
+                    logs = gr.Textbox(
+                        placeholder="\n" * 16,
+                        label="Logs",
+                        info="Verbose from inference will be displayed below.",
+                        lines=38,
+                        max_lines=38,
+                        autoscroll=True,
+                        elem_id="logs",
+                        show_copy_button=True,
+                        scroll_to_output=False,
+                        container=True,
+                        line_breaks=True,
+                    )
+                    demo.load(read_logs, None, logs, every=1)
+
+                with gr.Column():
+                    with gr.Row():
+                        with gr.Column(scale=0.2, min_width=150):
+                            sidebar_state = gr.State(True)
+
+                            btn_toggle_sidebar = gr.Button(
+                                "Toggle Sidebar",
+                                elem_id="toggle-button",
+                            )
+                            btn_toggle_sidebar.click(
+                                self.toggle_sidebar,
+                                [sidebar_state],
+                                [sidebar_left, sidebar_state],
+                            )
+
+                            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
+                        )
+
+                        model_selector = gr.Dropdown(
+                            list(self.class_names.keys()),
+                            label="Task",
+                            info="Which structure to segment.",
+                            multiselect=False,
+                            size="sm",
+                        )
+                        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",
+                            ).style(
+                                full_width=False,
+                                size="lg",
+                            )
+                            run_btn.click(
+                                fn=lambda x: self.process(x),
+                                inputs=file_output,
+                                outputs=self.volume_renderer,
+                            )
+
+                    with gr.Row():
+                        gr.Examples(
+                            examples=[
+                                os.path.join(self.cwd, "test_thorax_CT.nii.gz"),
+                            ],
+                            inputs=file_output,
+                            outputs=file_output,
+                            fn=self.upload_file,
+                            cache_examples=True,
+                        )
+
+                        gr.Markdown(
+                            """
+                            **NOTE:** Inference might take several minutes (Lymph nodes: ~8 minutes), see logs to the left. \\
+                            The segmentation will be available in the 2D and 3D viewers below when finished.
+                            """
+                        )
+
+                    with gr.Row():
+                        with gr.Box():
+                            with gr.Column():
+                                # create dummy image to be replaced by loaded images
+                                t = gr.AnnotatedImage(
+                                    visible=True, elem_id="model-2d"
+                                ).style(
+                                    color_map={self.class_name: "#ffae00"},
+                                    height=512,
+                                    width=512,
+                                )
+
+                                self.slider.input(
+                                    self.get_img_pred_pair,
+                                    self.slider,
+                                    t,
+                                )
+
+                                self.slider.render()
+
+                        with gr.Box():
+                            self.volume_renderer.render()
+
+        # sharing app publicly -> share=True:
+        # https://gradio.app/sharing-your-app/
+        # inference times > 60 seconds -> need queue():
+        # https://github.com/tloen/alpaca-lora/issues/60#issuecomment-1510006062
+        demo.queue().launch(
+            server_name="0.0.0.0", server_port=7860, share=self.share
+        )

demo/src/inference.py

@@ -0,0 +1,101 @@
+import configparser
+import logging
+import os
+import shutil
+import traceback
+
+
+def run_model(
+    input_path: str,
+    model_path: str,
+    verbose: str = "info",
+    task: str = "CT_LymphNodes",
+    name: str = "Lymph nodes",
+):
+    if verbose == "debug":
+        logging.getLogger().setLevel(logging.DEBUG)
+    elif verbose == "info":
+        logging.getLogger().setLevel(logging.INFO)
+    elif verbose == "error":
+        logging.getLogger().setLevel(logging.ERROR)
+    else:
+        raise ValueError("Unsupported verbose value provided:", verbose)
+
+    # delete patient/result folder if they exist
+    if os.path.exists("./patient/"):
+        shutil.rmtree("./patient/")
+    if os.path.exists("./result/"):
+        shutil.rmtree("./result/")
+
+    patient_directory = ""
+    output_path = ""
+    try:
+        # setup temporary patient directory
+        filename = input_path.split("/")[-1]
+        splits = filename.split(".")
+        extension = ".".join(splits[1:])
+        patient_directory = "./patient/"
+        os.makedirs(patient_directory + "T0/", exist_ok=True)
+        shutil.copy(
+            input_path,
+            patient_directory + "T0/" + splits[0] + "-t1gd." + extension,
+        )
+
+        # define output directory to save results
+        output_path = "./result/prediction-" + splits[0] + "/"
+        os.makedirs(output_path, exist_ok=True)
+
+        # Setting up the configuration file
+        rads_config = configparser.ConfigParser()
+        rads_config.add_section("Default")
+        rads_config.set("Default", "task", "mediastinum_diagnosis")
+        rads_config.set("Default", "caller", "")
+        rads_config.add_section("System")
+        rads_config.set("System", "gpu_id", "-1")
+        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.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")
+
+        with open("rads_config.ini", "w") as f:
+            rads_config.write(f)
+
+        # 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",
+        )
+        # Clean-up
+        if os.path.exists(patient_directory):
+            shutil.rmtree(patient_directory)
+        if os.path.exists(output_path):
+            shutil.rmtree(output_path)
+
+    except Exception:
+        print(traceback.format_exc())
+        # Clean-up
+        if os.path.exists(patient_directory):
+            shutil.rmtree(patient_directory)
+        if os.path.exists(output_path):
+            shutil.rmtree(output_path)

demo/src/logger.py

@@ -0,0 +1,37 @@
+import logging
+import sys
+
+
+def get_logger():
+    return logging.getLogger(__name__)
+
+
+def setup_logger():
+    # clear log
+    file_to_delete = open("log.txt", "w")
+    file_to_delete.close()
+
+    file_handler = logging.FileHandler(filename="log.txt")
+    stdout_handler = logging.StreamHandler(stream=sys.stdout)
+    handlers = [file_handler, stdout_handler]
+
+    logging.basicConfig(
+        level=logging.INFO,
+        format="[%(asctime)s] {%(filename)s:%(lineno)d} %(levelname)s - %(message)s",
+        handlers=handlers,
+    )
+
+    return get_logger()
+
+
+def read_logs():
+    sys.stdout.flush()
+    with open("log.txt", "r") as f:
+        return f.read()
+
+
+def flush_logs():
+    sys.stdout.flush()
+    # clear log
+    file_to_delete = open("log.txt", "w")
+    file_to_delete.close()

demo/src/utils.py

@@ -0,0 +1,40 @@
+import nibabel as nib
+import numpy as np
+
+
+def load_ct_to_numpy(data_path):
+    if not isinstance(data_path, str):
+        data_path = data_path.name
+
+    image = nib.load(data_path)
+    data = image.get_fdata()
+
+    data = np.rot90(data, k=1, axes=(0, 1))
+    data = np.flip(data, axis=0)
+
+    data[data < -1024] = 1024
+    data[data > 1024] = 1024
+
+    data = data - np.amin(data)
+    data = data / np.amax(data) * 255
+    data = data.astype("uint8")
+
+    print(data.shape)
+    return [data[..., i] for i in range(data.shape[-1])]
+
+
+def load_pred_volume_to_numpy(data_path):
+    if not isinstance(data_path, str):
+        data_path = data_path.name
+
+    image = nib.load(data_path)
+    data = image.get_fdata()
+
+    data = np.rot90(data, k=1, axes=(0, 1))
+    data = np.flip(data, axis=0)
+
+    data[data > 0] = 1
+    data = data.astype("uint8")
+
+    print(data.shape)
+    return [data[..., i] for i in range(data.shape[-1])]

setup.cfg

@@ -0,0 +1,14 @@
+[metadata]
+description-file = README.md
+
+[isort]
+force_single_line=True
+known_first_party=lynos
+line_length=160
+profile=black
+
+[flake8]
+# imported but unused in __init__.py, that's ok.
+per-file-ignores=*__init__.py:F401
+ignore=E203,W503,W605,F632,E266,E731,E712,E741
+max-line-length=160