initial commit

README.md

@@ -1,14 +1,26 @@
----
-title: 3d Lungs Segmentation
-emoji: 🔥
-colorFrom: gray
-colorTo: purple
-sdk: gradio
-sdk_version: 5.23.1
-app_file: app.py
-pinned: false
-license: bsd-3-clause
-short_description: A web-based application for automated lung segmentation.
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🖥️ Lungs segmentation web application
+A web-based application for automated lung segmentation using deep learning, powered by **Gradio** and **PyTorch**. This tool allows users to upload lung images and obtain segmented outputs efficiently.
+
+<p align="center">
+    <img src="https://raw.githubusercontent.com/titi1000/lungs-segmentation-app/refs/heads/master/images/app.png" height="700">
+</p>
+
+## Installation
+We recommend performing the installation in a clean Python environment.
+
+The code requires `python>=3.10`, as well as `pytorch>=2.0`. Please install Pytorch first and separately following the instructions for your platform on [pytorch.org](https://pytorch.org/get-started/locally/).
+
+After that please run the following command:
+```sh
+pip install -r requirements.txt
+```
+
+## Usage
+Run:
+```sh
+python app.py
+```
+And go to http://localhost:7860/.
+
+## About Lungs Segmentation
+If you are interesten in the package used for segmentation please check the following [GitHub repository](https://github.com/titi1000/lungs-segmentation)!

app.py

@@ -0,0 +1,150 @@
+import gradio as gr
+from core.utils import *
+
+def get_axis_max(volume, axis):
+    """Get the maximum index of each axis."""
+    if volume is None:
+        return 0
+    shape = volume.shape
+    return shape[{"Z": 0, "Y": 1, "X": 2}[axis]] - 1
+
+def reset_app():
+    """Reset everything to the initial state."""
+    return (
+        gr.update(value=None),
+        None,
+        None,
+        gr.update(visible=False),
+        gr.update(value=0), gr.update(value=0), gr.update(value=0),
+        gr.update(value=None), gr.update(value=None), gr.update(value=None),
+        gr.update(visible=False),
+        gr.update(value=0), gr.update(value=0), gr.update(value=0),
+        gr.update(value=None), gr.update(value=None), gr.update(value=None)
+    )
+
+with gr.Blocks() as demo:
+    gr.Markdown("# 🐭 3D Lungs Segmentation")
+    gr.Markdown("### ⚠️ Note: the visualization may take some time to render!")
+
+    volume_state = gr.State()
+    seg_state = gr.State()
+
+    file_input = gr.File(file_types=[".tif", ".tiff"], label="Upload your 3D TIF or TIFF file")
+
+    # ---- RAW SLICES VIEWER ----
+    with gr.Group(visible=False) as group_input:
+        gr.Markdown("### Raw Volume Slices")
+        with gr.Row():
+            z_slider = gr.Slider(0, 0, step=1, label="Z Slice")
+            y_slider = gr.Slider(0, 0, step=1, label="Y Slice")
+            x_slider = gr.Slider(0, 0, step=1, label="X Slice")
+        with gr.Row():
+            z_img = gr.Image(label="Z")
+            y_img = gr.Image(label="Y")
+            x_img = gr.Image(label="X")
+
+    segment_btn = gr.Button("Segment", visible=False)   
+
+    # ---- OVERLAY SLICES VIEWER ----
+    with gr.Group(visible=False) as group_seg:
+        gr.Markdown("### Segmentation Overlay Slices")
+        with gr.Row():
+            z_slider_seg = gr.Slider(0, 0, step=1, label="Z Slice (Overlay)")
+            y_slider_seg = gr.Slider(0, 0, step=1, label="Y Slice (Overlay)")
+            x_slider_seg = gr.Slider(0, 0, step=1, label="X Slice (Overlay)")
+        with gr.Row():
+            z_img_overlay = gr.Image(label="Z + Mask")
+            y_img_overlay = gr.Image(label="Y + Mask")
+            x_img_overlay = gr.Image(label="X + Mask")
+
+    reset_btn = gr.Button("Reset")
+
+    # ---- CALLBACKS ----
+
+    # A) Load volume
+    file_input.change(
+        fn=load_volume,
+        inputs=file_input,
+        outputs=volume_state
+    ).then(
+        fn=lambda vol: gr.update(visible=(vol is not None)),
+        inputs=volume_state,
+        outputs=group_input
+    ).then(
+        fn=lambda vol: gr.update(visible=(vol is not None)),
+        inputs=volume_state,
+        outputs=segment_btn
+    ).then(
+        fn=lambda vol: (
+            gr.update(maximum=get_axis_max(vol, "Z")),
+            gr.update(maximum=get_axis_max(vol, "Y")),
+            gr.update(maximum=get_axis_max(vol, "X")),
+        ),
+        inputs=volume_state,
+        outputs=[z_slider, y_slider, x_slider]
+    ).then(
+        fn=lambda vol: (
+            browse_axis("Z", 0, vol),
+            browse_axis("Y", 0, vol),
+            browse_axis("X", 0, vol),
+        ),
+        inputs=volume_state,
+        outputs=[z_img, y_img, x_img]
+    )
+
+    # B) RAW sliders
+    z_slider.change(fn=lambda idx, vol: browse_axis("Z", idx, vol), inputs=[z_slider, volume_state], outputs=z_img)
+    y_slider.change(fn=lambda idx, vol: browse_axis("Y", idx, vol), inputs=[y_slider, volume_state], outputs=y_img)
+    x_slider.change(fn=lambda idx, vol: browse_axis("X", idx, vol), inputs=[x_slider, volume_state], outputs=x_img)
+
+    # C) Segment
+    segment_btn.click(
+        fn=segment_volume,
+        inputs=volume_state,
+        outputs=seg_state
+    ).then(
+        fn=lambda s: gr.update(visible=(s is not None)),
+        inputs=seg_state,
+        outputs=group_seg
+    ).then(
+        fn=lambda vol: (
+            gr.update(maximum=get_axis_max(vol, "Z")),
+            gr.update(maximum=get_axis_max(vol, "Y")),
+            gr.update(maximum=get_axis_max(vol, "X")),
+        ),
+        inputs=volume_state,
+        outputs=[z_slider_seg, y_slider_seg, x_slider_seg]
+    ).then(
+        fn=lambda z, y, x, vol, seg: (
+            browse_overlay_axis("Z", z, vol, seg),
+            browse_overlay_axis("Y", y, vol, seg),
+            browse_overlay_axis("X", x, vol, seg),
+        ),
+        inputs=[z_slider_seg, y_slider_seg, x_slider_seg, volume_state, seg_state],
+        outputs=[z_img_overlay, y_img_overlay, x_img_overlay]
+    )
+
+    # D) OVERLAY sliders
+    z_slider_seg.change(fn=lambda idx, vol, seg: browse_overlay_axis("Z", idx, vol, seg), inputs=[z_slider_seg, volume_state, seg_state], outputs=z_img_overlay)
+    y_slider_seg.change(fn=lambda idx, vol, seg: browse_overlay_axis("Y", idx, vol, seg), inputs=[y_slider_seg, volume_state, seg_state], outputs=y_img_overlay)
+    x_slider_seg.change(fn=lambda idx, vol, seg: browse_overlay_axis("X", idx, vol, seg), inputs=[x_slider_seg, volume_state, seg_state], outputs=x_img_overlay)
+
+    # E) Reset
+    reset_btn.click(
+        fn=reset_app,
+        inputs=[],
+        outputs=[
+            file_input,
+            volume_state,
+            seg_state,
+            group_input,
+            z_slider, y_slider, x_slider,
+            z_img, y_img, x_img,
+            group_seg,
+            z_slider_seg, y_slider_seg, x_slider_seg,
+            z_img_overlay, y_img_overlay, x_img_overlay
+        ]
+    )
+
+if __name__ == "__main__":
+    demo.launch()

core/utils.py

@@ -0,0 +1,70 @@
+import numpy as np
+import tifffile
+from PIL import Image
+from unet_lungs_segmentation import LungsPredict
+
+model = LungsPredict()
+
+def _to_8bit(arr):
+    """Convert float/int array to 8-bit [0..255]."""
+    arr = arr.astype(np.float32)
+    mn, mx = arr.min(), arr.max()
+    rng = mx - mn
+    if rng < 1e-8:
+        rng = 1.0
+    norm = (arr - mn) / rng
+    return (norm * 255).astype(np.uint8)
+
+def load_volume(file_obj):
+    """Read the uploaded TIF as a NumPy array (Z, Y, X)."""
+    if not file_obj:
+        return None
+    return tifffile.imread(file_obj.name)
+
+def segment_volume(volume):
+    """Run segmentation on the loaded volume (return shape (Z, Y, X))."""
+    if volume is None:
+        return None
+    return model.segment_lungs(volume)
+
+def browse_axis(axis, idx, volume):
+    """Return a single raw slice for the given axis."""
+    if volume is None:
+        return None
+
+    if axis == "Z":
+        slice_ = volume[idx]
+    elif axis == "Y":
+        slice_ = volume[:, idx, :]
+    elif axis == "X":
+        slice_ = volume[:, :, idx]
+    else:
+        return None
+
+    return Image.fromarray(_to_8bit(slice_))
+
+def browse_overlay_axis(axis, idx, volume, seg):
+    """Return a single overlay slice for the given axis."""
+    if volume is None or seg is None:
+        return None
+
+    if axis == "Z":
+        raw = volume[idx]
+        mask = seg[idx]
+    elif axis == "Y":
+        raw = volume[:, idx, :]
+        mask = seg[:, idx, :]
+    elif axis == "X":
+        raw = volume[:, :, idx]
+        mask = seg[:, :, idx]
+    else:
+        return None
+
+    raw_8bit = _to_8bit(raw)
+    raw_rgb = np.stack([raw_8bit] * 3, axis=-1)
+    mask_rgb = np.zeros_like(raw_rgb)
+    mask_rgb[..., 0] = (mask * 255).astype(np.uint8)
+
+    alpha = 0.3
+    blended = (1 - alpha) * raw_rgb + alpha * mask_rgb
+    return Image.fromarray(blended.astype(np.uint8))

requirements.txt

@@ -0,0 +1,4 @@
+unet_lungs_segmentation==1.0.6
+gradio==4.44.1
+torch==2.6.0
+torchvision==0.21.0