New version

Dockerfile

@@ -0,0 +1,21 @@
+FROM python:3.9-slim
+
+EXPOSE 8501
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    software-properties-common \
+    git \
+    wget \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN git clone https://github.com/lambda-science/MyoQuant.git .
+RUN wget https://lbgi.fr/~meyer/SDH_models/model.h5
+
+RUN python -m pip install poetry
+RUN python -m poetry config virtualenvs.create false
+RUN python -m poetry install --no-root --no-interaction && rm -rf ~/.cache/pypoetry/{cache,artifacts}
+
+ENTRYPOINT ["streamlit", "run", "Home.py", "--server.port=8501", "--server.address=0.0.0.0"]

README.md

@@ -21,14 +21,33 @@ MyoQuant-Streamlit🔬 is a demo web interface to showcase the usage of MyoQuant
 </p>
 
 MyoQuant🔬 is a command-line tool to automatically quantify pathological features in muscle fiber histology images.  
-It is built using CellPose, Stardist, custom neural-network models and image analysis techniques to automatically analyze myopathy histology images. Currently MyoQuant is capable of quantifying centralization of nuclei in muscle fiber with HE staining and anomaly in the mitochondria distribution in muscle fibers with SDH staining.  
+It is built using CellPose, Stardist, custom neural-network models and image analysis techniques to automatically analyze myopathy histology images. Currently MyoQuant is capable of quantifying centralization of nuclei in muscle fiber with HE staining, anomaly in the mitochondria distribution in muscle fibers with SDH staining and the number of type 1 muscle fiber vs type 2 muscle fiber with ATP staining.  
 This web application is intended for demonstration purposes only.
 
-## How to Use 
-This space is deployed at https://huggingface.co/spaces/corentinm7/MyoQuant  
-Once on the space, click on the corresponding staining analysis on the sidebar, and upload your histology image. Results will be displayed in the main area automatically.  
+## How to install or deploy the interface
+
+The demo version is deployed at https://lbgi.fr/MyoQuant/. You can deploy your own demo version using Docker, your own python environment or google Colab for GPU support.
+
+### Docker
+
+You can build the docker image by running `docker build -t streamlit .` and launch the container using `docker run -p 8501:8501 streamlit`.
+
+### Non-Docker
+
+If you do not want to use Docker you can install the poetry package in a miniconda (python 3.9, 3.10) base env, run `poetry install` to install the python env, activate the env with `poetry shell` and launch the app by running `streamlit run Home.py`.
+
+### Deploy on Google Colab for GPU
+
+As this application uses various deep-learning model, you could benefit from using a deployment solution that provides a GPU.  
+To do so, you can leverage Google Colab free GPU to boost this Streamlit application.  
+To run this app on Google Colab, simply clone the notebook called `google_colab_deploy.ipynb` into Colab and run the four cells. It will automatically download the latest code version, install dependencies and run the app. A link will appear in the output of the lat cell with a structure like `https://word1-word2-try-01-234-567-890.loca.lt`. Click it and the click continue and you’re ready to use the app!
+
+## How to Use
+
+Once on the demo, click on the corresponding staining analysis on the sidebar, and upload your histology image. Results will be displayed in the main area automatically.  
 For HE Staining analysis, you can download this sample image: [HERE](https://www.lbgi.fr/~meyer/SDH_models/sample_he.jpg)  
-For SDH Staining analysis, you can download this sample image: [HERE](https://www.lbgi.fr/~meyer/SDH_models/sample_sdh.jpg)
+For SDH Staining analysis, you can download this sample image: [HERE](https://www.lbgi.fr/~meyer/SDH_models/sample_sdh.jpg)  
+For ATP Staining analysis, you can download this sample image: [HERE](https://www.lbgi.fr/~meyer/SDH_models/sample_atp.jpg)
 
 ## Contact
 
@@ -46,4 +65,3 @@ The source code for MyoQuant is available [HERE](https://github.com/lambda-scien
 </p>
 
 MyoQuant is born within the collaboration between the [CSTB Team @ ICube](https://cstb.icube.unistra.fr/en/index.php/Home) led by Julie D. Thompson, the [Morphological Unit of the Institute of Myology of Paris](https://www.institut-myologie.org/en/recherche-2/neuromuscular-investigation-center/morphological-unit/) led by Teresinha Evangelista, the [imagery platform MyoImage of Center of Research in Myology](https://recherche-myologie.fr/technologies/myoimage/) led by Bruno Cadot, [the photonic microscopy platform of the IGMBC](https://www.igbmc.fr/en/plateformes-technologiques/photonic-microscopy) led by Bertrand Vernay and the [Pathophysiology of neuromuscular diseases team @ IGBMC](https://www.igbmc.fr/en/igbmc/a-propos-de-ligbmc/directory/jocelyn-laporte) led by Jocelyn Laporte
-

pages/1_HE_Staining_Analysis.py

@@ -1,209 +1,118 @@
 import streamlit as st
 from streamlit.components.v1 import html
-from cellpose import models, core
-from stardist.models import StarDist2D
-from csbdeep.utils import normalize
 import matplotlib
 
 try:
     from imageio.v2 import imread
 except:
     from imageio import imread
-from skimage.measure import regionprops_table
-import pandas as pd
 import matplotlib.pyplot as plt
 from stardist import random_label_cmap
-from tensorflow.config import list_physical_devices
-from draw_line import *
-from skimage.draw import line
-import numpy as np
+from myoquant.src.common_func import (
+    load_cellpose,
+    load_stardist,
+    run_cellpose,
+    run_stardist,
+    is_gpu_availiable,
+    df_from_cellpose_mask,
+    df_from_stardist_mask,
+)
+from myoquant.src.HE_analysis import (
+    predict_all_cells,
+    extract_ROIs,
+    single_cell_analysis,
+    paint_histo_img,
+)
 
 st.set_page_config(
     page_title="MyoQuant HE Analysis",
     page_icon="🔬",
 )
 
-if len(list_physical_devices("GPU")) >= 1:
-    use_GPU = True
-else:
-    use_GPU = False
+use_GPU = is_gpu_availiable()
 
 
 @st.experimental_singleton
-def load_cellpose():
-    model_c = models.Cellpose(gpu=use_GPU, model_type="cyto2")
-    return model_c
+def st_load_cellpose():
+    return load_cellpose()
 
 
 @st.experimental_singleton
-def load_stardist():
-    model_s = StarDist2D.from_pretrained("2D_versatile_he")
-    return model_s
+def st_load_stardist():
+    return load_stardist()
 
 
 @st.experimental_memo
-def run_cellpose(image):
-    channel = [[0, 0]]
-    mask_cellpose, flow, style, diam = model_cellpose.eval(
-        image, diameter=None, channels=channel
-    )
-    return mask_cellpose
+def st_run_cellpose(image_ndarray, _model):
+    return run_cellpose(image_ndarray, _model)
 
 
 @st.experimental_memo
-def run_stardist(image, nms_thresh=0.4, prob_thresh=0.5):
-    img_norm = image / 255
-    img_norm = normalize(img_norm, 1, 99.8)
-    mask_stardist, details = model_stardist.predict_instances(
-        img_norm, nms_thresh=nms_thresh, prob_thresh=prob_thresh
-    )
-    return mask_stardist
+def st_run_stardist(image_ndarray, _model, nms_thresh, prob_thresh):
+    return run_stardist(image_ndarray, _model, nms_thresh, prob_thresh)
 
 
 @st.experimental_memo
-def extract_ROIs(histo_img, index, cellpose_df, mask_stardist):
-    single_cell_img = histo_img[
-        cellpose_df.iloc[index, 5] : cellpose_df.iloc[index, 7],
-        cellpose_df.iloc[index, 6] : cellpose_df.iloc[index, 8],
-    ].copy()
-    nucleus_single_cell_img = mask_stardist[
-        cellpose_df.iloc[index, 5] : cellpose_df.iloc[index, 7],
-        cellpose_df.iloc[index, 6] : cellpose_df.iloc[index, 8],
-    ].copy()
-    single_cell_mask = cellpose_df.iloc[index, 9]
-    single_cell_img[~single_cell_mask] = 0
-    nucleus_single_cell_img[~single_cell_mask] = 0
-
-    props_nuc_single = regionprops_table(
-        nucleus_single_cell_img,
-        intensity_image=single_cell_img,
-        properties=[
-            "label",
-            "area",
-            "centroid",
-            "eccentricity",
-            "bbox",
-            "image",
-            "perimeter",
-        ],
-    )
-    df_nuc_single = pd.DataFrame(props_nuc_single)
-    return single_cell_img, nucleus_single_cell_img, single_cell_mask, df_nuc_single
+def st_df_from_cellpose_mask(mask):
+    return df_from_cellpose_mask(mask)
 
 
 @st.experimental_memo
-def single_cell_analysis(
-    single_cell_img,
-    single_cell_mask,
-    df_nuc_single,
-    x_fiber,
-    y_fiber,
-    internalised_threshold=0.75,
-):
-    n_nuc, n_nuc_intern, n_nuc_periph = 0, 0, 0
-    for _, value in df_nuc_single.iterrows():
-        n_nuc += 1
-        # Extend line and find closest point
-        m, b = line_equation(x_fiber, y_fiber, value[3], value[2])
-
-        intersections_lst = calculate_intersection(
-            m, b, (single_cell_img.shape[0], single_cell_img.shape[1])
-        )
-        border_point = calculate_closest_point(value[3], value[2], intersections_lst)
-        rr, cc = line(
-            int(y_fiber),
-            int(x_fiber),
-            int(border_point[1]),
-            int(border_point[0]),
-        )
-        for index3, coords in enumerate(list(zip(rr, cc))):
-            try:
-                if single_cell_mask[coords] == 0:
-                    dist_nuc_cent = calculate_distance(
-                        x_fiber, y_fiber, value[3], value[2]
-                    )
-                    dist_out_of_fiber = calculate_distance(
-                        x_fiber, y_fiber, coords[1], coords[0]
-                    )
-                    ratio_dist = dist_nuc_cent / dist_out_of_fiber
-                    if ratio_dist < internalised_threshold:
-                        n_nuc_intern += 1
-                    else:
-                        n_nuc_periph += 1
-                    break
-            except IndexError:
-                coords = list(zip(rr, cc))[index3 - 1]
-                dist_nuc_cent = calculate_distance(x_fiber, y_fiber, value[3], value[2])
-                dist_out_of_fiber = calculate_distance(
-                    x_fiber, y_fiber, coords[1], coords[0]
-                )
-                ratio_dist = dist_nuc_cent / dist_out_of_fiber
-                if ratio_dist < internalised_threshold:
-                    n_nuc_intern += 1
-                else:
-                    n_nuc_periph += 1
-                break
-
-    return n_nuc, n_nuc_intern, n_nuc_periph
+def st_df_from_stardist_mask(mask):
+    return df_from_stardist_mask(mask)
 
 
 @st.experimental_memo
-def predict_all_cells(
-    histo_img, cellpose_df, mask_stardist, internalised_threshold=0.75
+def st_predict_all_cells(
+    image_ndarray, df_cellpose, mask_stardist, internalised_threshold
 ):
-    list_n_nuc, list_n_nuc_intern, list_n_nuc_periph = [], [], []
-    for index in range(len(cellpose_df)):
-        (
-            single_cell_img,
-            _,
-            single_cell_mask,
-            df_nuc_single,
-        ) = extract_ROIs(histo_img, index, cellpose_df, mask_stardist)
-        x_fiber = cellpose_df.iloc[index, 3] - cellpose_df.iloc[index, 6]
-        y_fiber = cellpose_df.iloc[index, 2] - cellpose_df.iloc[index, 5]
-        n_nuc, n_nuc_intern, n_nuc_periph = single_cell_analysis(
-            single_cell_img, single_cell_mask, df_nuc_single, x_fiber, y_fiber
-        )
-        list_n_nuc.append(n_nuc)
-        list_n_nuc_intern.append(n_nuc_intern)
-        list_n_nuc_periph.append(n_nuc_periph)
-        df_nuc_analysis = pd.DataFrame(
-            list(zip(list_n_nuc, list_n_nuc_intern, list_n_nuc_periph)),
-            columns=["N° Nuc", "N° Nuc Intern", "N° Nuc Periph"],
-        )
-    return df_nuc_analysis
+    return predict_all_cells(
+        image_ndarray, df_cellpose, mask_stardist, internalised_threshold
+    )
+
+
+@st.experimental_memo
+def st_extract_ROIs(image_ndarray, selected_fiber, df_cellpose, mask_stardist):
+    return extract_ROIs(image_ndarray, selected_fiber, df_cellpose, mask_stardist)
 
 
 @st.experimental_memo
-def predict_single_cell(histo_img, cellpose_df, mask_stardist):
-    pass
+def st_single_cell_analysis(
+    single_cell_img,
+    single_cell_mask,
+    df_nuc_single,
+    x_fiber,
+    y_fiber,
+    selected_fiber,
+    internalised_threshold,
+    draw_and_return=True,
+):
+    return single_cell_analysis(
+        single_cell_img,
+        single_cell_mask,
+        df_nuc_single,
+        x_fiber,
+        y_fiber,
+        selected_fiber + 1,
+        internalised_threshold,
+        draw_and_return=True,
+    )
 
 
 @st.experimental_memo
-def paint_histo_img(histo_img, cellpose_df, prediction_df):
-    paint_img = np.zeros((histo_img.shape[0], histo_img.shape[1]), dtype=np.uint8)
-    for index in range(len(cellpose_df)):
-        single_cell_mask = cellpose_df.iloc[index, 9].copy()
-        if prediction_df.iloc[index, 1] == 0:
-            paint_img[
-                cellpose_df.iloc[index, 5] : cellpose_df.iloc[index, 7],
-                cellpose_df.iloc[index, 6] : cellpose_df.iloc[index, 8],
-            ][single_cell_mask] = 1
-        elif prediction_df.iloc[index, 1] > 0:
-            paint_img[
-                cellpose_df.iloc[index, 5] : cellpose_df.iloc[index, 7],
-                cellpose_df.iloc[index, 6] : cellpose_df.iloc[index, 8],
-            ][single_cell_mask] = 2
-    return paint_img
+def st_paint_histo_img(image_ndarray, df_cellpose, cellpose_df_stat):
+    return paint_histo_img(image_ndarray, df_cellpose, cellpose_df_stat)
 
 
 with st.sidebar:
-    st.write("Models Parameters")
+    st.write("Nuclei detection Parameters (Stardist)")
     nms_thresh = st.slider("Stardist NMS Tresh", 0.0, 1.0, 0.4, 0.1)
     prob_thresh = st.slider("Stardist Prob Tresh", 0.5, 1.0, 0.5, 0.05)
+    st.write("Nuclei Classification Parameter")
+    eccentricity_thresh = st.slider("Eccentricity Score Tresh", 0.0, 1.0, 0.75, 0.05)
 
-model_cellpose = load_cellpose()
-model_stardist = load_stardist()
+model_cellpose = st_load_cellpose()
+model_stardist = st_load_stardist()
 
 st.title("HE Staining Analysis")
 st.write(
@@ -217,10 +126,11 @@ if uploaded_file is not None:
     st.write("Raw Image")
     image = st.image(uploaded_file)
 
-    mask_cellpose = run_cellpose(image_ndarray)
-    mask_stardist = run_stardist(image_ndarray, nms_thresh, prob_thresh)
+    mask_cellpose = st_run_cellpose(image_ndarray, model_cellpose)
+    mask_stardist = st_run_stardist(
+        image_ndarray, model_stardist, nms_thresh, prob_thresh
+    )
     mask_stardist_copy = mask_stardist.copy()
-
     st.header("Segmentation Results")
     st.subheader("CellPose and Stardist overlayed results")
     fig, ax = plt.subplots(1, 1)
@@ -231,90 +141,78 @@ if uploaded_file is not None:
     st.pyplot(fig)
 
     st.subheader("All cells detected by CellPose")
-    props_cellpose = regionprops_table(
-        mask_cellpose,
-        properties=[
-            "label",
-            "area",
-            "centroid",
-            "eccentricity",
-            "bbox",
-            "image",
-            "perimeter",
-        ],
-    )
-    df_cellpose = pd.DataFrame(props_cellpose)
-    st.dataframe(df_cellpose.drop("image", axis=1))
+    df_cellpose = st_df_from_cellpose_mask(mask_cellpose)
 
     st.header("Full Nucleus Analysis Results")
-    df_nuc_analysis = predict_all_cells(image_ndarray, df_cellpose, mask_stardist)
-    st.dataframe(df_nuc_analysis)
-    st.write("Total number of nucleus : ", df_nuc_analysis["N° Nuc"].sum())
+    cellpose_df_stat, all_nuc_df_stats = st_predict_all_cells(
+        image_ndarray,
+        df_cellpose,
+        mask_stardist,
+        internalised_threshold=eccentricity_thresh,
+    )
+    st.dataframe(
+        cellpose_df_stat.drop(
+            [
+                "centroid-0",
+                "centroid-1",
+                "bbox-0",
+                "bbox-1",
+                "bbox-2",
+                "bbox-3",
+                "image",
+            ],
+            axis=1,
+        )
+    )
+    st.write("Total number of nucleus : ", cellpose_df_stat["N° Nuc"].sum())
     st.write(
         "Total number of internalized nucleus : ",
-        df_nuc_analysis["N° Nuc Intern"].sum(),
+        cellpose_df_stat["N° Nuc Intern"].sum(),
         " (",
         round(
             100
-            * df_nuc_analysis["N° Nuc Intern"].sum()
-            / df_nuc_analysis["N° Nuc"].sum(),
+            * cellpose_df_stat["N° Nuc Intern"].sum()
+            / cellpose_df_stat["N° Nuc"].sum(),
             2,
         ),
         "%)",
     )
     st.write(
         "Total number of peripherical nucleus : ",
-        df_nuc_analysis["N° Nuc Periph"].sum(),
+        cellpose_df_stat["N° Nuc Periph"].sum(),
         " (",
         round(
             100
-            * df_nuc_analysis["N° Nuc Periph"].sum()
-            / df_nuc_analysis["N° Nuc"].sum(),
+            * cellpose_df_stat["N° Nuc Periph"].sum()
+            / cellpose_df_stat["N° Nuc"].sum(),
             2,
         ),
         "%)",
     )
     st.write(
         "Number of cell with at least one internalized nucleus : ",
-        df_nuc_analysis["N° Nuc Intern"].astype(bool).sum(axis=0),
+        cellpose_df_stat["N° Nuc Intern"].astype(bool).sum(axis=0),
         " (",
         round(
             100
-            * df_nuc_analysis["N° Nuc Intern"].astype(bool).sum(axis=0)
-            / len(df_nuc_analysis),
+            * cellpose_df_stat["N° Nuc Intern"].astype(bool).sum(axis=0)
+            / len(cellpose_df_stat),
             2,
         ),
         "%)",
     )
+
     st.header("Single Nucleus Analysis Details")
     selected_fiber = st.selectbox("Select a cell", list(range(len(df_cellpose))))
     selected_fiber = int(selected_fiber)
-    single_cell_img = image_ndarray[
-        df_cellpose.iloc[selected_fiber, 5] : df_cellpose.iloc[selected_fiber, 7],
-        df_cellpose.iloc[selected_fiber, 6] : df_cellpose.iloc[selected_fiber, 8],
-    ]
-    nucleus_single_cell_img = mask_stardist_copy[
-        df_cellpose.iloc[selected_fiber, 5] : df_cellpose.iloc[selected_fiber, 7],
-        df_cellpose.iloc[selected_fiber, 6] : df_cellpose.iloc[selected_fiber, 8],
-    ]
-    single_cell_mask = df_cellpose.iloc[selected_fiber, 9]
-    single_cell_img[~single_cell_mask] = 0
-    nucleus_single_cell_img[~single_cell_mask] = 0
-
-    props_nuc_single = regionprops_table(
+    (
+        single_cell_img,
         nucleus_single_cell_img,
-        intensity_image=single_cell_img,
-        properties=[
-            "label",
-            "area",
-            "centroid",
-            "eccentricity",
-            "bbox",
-            "image",
-            "perimeter",
-        ],
-    )
-    df_nuc_single = pd.DataFrame(props_nuc_single)
+        single_cell_mask,
+        df_nuc_single,
+    ) = st_extract_ROIs(image_ndarray, selected_fiber, df_cellpose, mask_stardist)
+
+    # df_nuc_single = df_from_stardist_mask(mask_stardist)
     st.markdown(
         """
         * White point represent cell centroid. 
@@ -322,93 +220,74 @@ if uploaded_file is not None:
         * Red point represent the cell border from a straight line between the cell centroid and the nucleus centroid. The red dashed line represent distance between the nucelus and the cell border. 
         * The periphery ratio is calculated by the division of the distance centroid - nucleus and the distance centroid - cell border."""
     )
-    fig2, (ax1, ax2, ax3) = plt.subplots(1, 3)
+
+    fig2, (ax1, ax2) = plt.subplots(1, 2)
     ax1.imshow(single_cell_img)
     ax2.imshow(nucleus_single_cell_img, cmap="viridis")
     # Plot Fiber centroid
     x_fiber = df_cellpose.iloc[selected_fiber, 3] - df_cellpose.iloc[selected_fiber, 6]
     y_fiber = df_cellpose.iloc[selected_fiber, 2] - df_cellpose.iloc[selected_fiber, 5]
-    ax3.scatter(x_fiber, y_fiber, color="white")
-    # Plot nucleus centroid
-    for index, value in df_nuc_single.iterrows():
-        ax3.scatter(value[3], value[2], color="blue", s=2)
-        # Extend line and find closest point
-        m, b = line_equation(x_fiber, y_fiber, value[3], value[2])
-
-        intersections_lst = calculate_intersection(
-            m, b, (single_cell_img.shape[0], single_cell_img.shape[1])
-        )
-        border_point = calculate_closest_point(value[3], value[2], intersections_lst)
-        ax3.plot(
-            (x_fiber, border_point[0]),
-            (y_fiber, border_point[1]),
-            "ro--",
-            linewidth=1,
-            markersize=1,
-        )
-        ax3.plot(
-            (x_fiber, value[3]),
-            (y_fiber, value[2]),
-            "go--",
-            linewidth=1,
-            markersize=1,
-        )
 
-        rr, cc = line(
-            int(y_fiber),
-            int(x_fiber),
-            int(border_point[1]),
-            int(border_point[0]),
-        )
-        for index, coords in enumerate(list(zip(rr, cc))):
-            try:
-                if single_cell_mask[coords] == 0:
-                    dist_nuc_cent = calculate_distance(
-                        x_fiber, y_fiber, value[3], value[2]
-                    )
-                    dist_out_of_fiber = calculate_distance(
-                        x_fiber, y_fiber, coords[1], coords[0]
-                    )
-                    ratio_dist = dist_nuc_cent / dist_out_of_fiber
-                    ax3.scatter(coords[1], coords[0], color="red", s=10)
-                    break
-            except IndexError:
-                coords = list(zip(rr, cc))[index - 1]
-                dist_nuc_cent = calculate_distance(x_fiber, y_fiber, value[3], value[2])
-                dist_out_of_fiber = calculate_distance(
-                    x_fiber, y_fiber, coords[1], coords[0]
-                )
-                ratio_dist = dist_nuc_cent / dist_out_of_fiber
-                ax3.scatter(coords[1], coords[0], color="red", s=10)
-                break
-
-        st.write("Nucleus #{} has a periphery ratio of: {}".format(index, ratio_dist))
-    ax3.imshow(single_cell_img)
-    ax3.imshow(nucleus_single_cell_img, cmap="viridis", alpha=0.5)
+    (
+        n_nuc,
+        n_nuc_intern,
+        n_nuc_periph,
+        df_nuc_single_stats,
+        ax_nuc,
+    ) = st_single_cell_analysis(
+        single_cell_img,
+        single_cell_mask,
+        df_nuc_single,
+        x_fiber,
+        y_fiber,
+        selected_fiber + 1,
+        internalised_threshold=eccentricity_thresh,
+        draw_and_return=True,
+    )
+    for index, value in df_nuc_single_stats.iterrows():
+        st.write("Nucleus #{} has a periphery ratio of: {}".format(index, value[12]))
     ax1.axis("off")
     ax2.axis("off")
-    ax3.axis("off")
-    st.pyplot(fig2)
+    # st.pyplot(fig2)
+    ax_nuc.imshow(single_cell_img)
+    ax_nuc.imshow(nucleus_single_cell_img, cmap="viridis", alpha=0.5)
+    f = ax_nuc.figure
 
+    st.pyplot(fig2)
+    st.pyplot(f)
     st.subheader("All nucleus inside selected cell")
 
-    st.dataframe(df_nuc_single.drop("image", axis=1))
+    st.dataframe(
+        df_nuc_single_stats.drop(
+            [
+                "centroid-0",
+                "centroid-1",
+                "bbox-0",
+                "bbox-1",
+                "bbox-2",
+                "bbox-3",
+                "image",
+            ],
+            axis=1,
+        )
+    )
 
     st.header("Painted predicted image")
     st.write(
         "Green color indicates cells with only peripherical nuclei, red color indicates cells with at least one internal nucleus."
     )
-    painted_img = paint_histo_img(image_ndarray, df_cellpose, df_nuc_analysis)
-    fig3, ax3 = plt.subplots(1, 1)
+    painted_img = st_paint_histo_img(image_ndarray, df_cellpose, cellpose_df_stat)
+    fig4, ax4 = plt.subplots(1, 1)
     cmap = matplotlib.colors.LinearSegmentedColormap.from_list(
         "", ["white", "green", "red"]
     )
-    ax3.imshow(image_ndarray)
-    ax3.imshow(painted_img, cmap=cmap, alpha=0.5)
-    ax3.axis("off")
-    st.pyplot(fig3)
+    ax4.imshow(image_ndarray)
+    ax4.imshow(painted_img, cmap=cmap, alpha=0.5)
+    ax4.axis("off")
+    st.pyplot(fig4)
+
 html(
     f"""
-    <script defer data-domain="huggingface.co/spaces/corentinm7/myoquant" src="https://plausible.cmeyer.fr/js/script.js"></script>
+    <script defer data-domain="lbgi.fr/myoquant" src="https://plausible.cmeyer.fr/js/script.js"></script>
     """
-)
+)

pages/2_SDH_Staining_Analysis.py

@@ -1,140 +1,98 @@
 import streamlit as st
 from streamlit.components.v1 import html
-from cellpose.core import use_gpu
-from cellpose.models import Cellpose
 
 try:
     from imageio.v2 import imread
 except:
     from imageio import imread
-from skimage.measure import regionprops_table
 import pandas as pd
 import matplotlib
 import matplotlib.pyplot as plt
-from stardist import random_label_cmap
 import tensorflow as tf
-from tensorflow.config import list_physical_devices
-from tensorflow import keras
-
-from gradcam import *
+import numpy as np
 from os import path
 import urllib.request
-from random_brightness import *
-
-labels_predict = ["control", "sick"]
-
-tf.random.set_seed(42)
-np.random.seed(42)
+from myoquant.src.SDH_analysis import (
+    predict_all_cells,
+    predict_single_cell,
+    paint_full_image,
+)
+from myoquant.src.common_func import (
+    load_cellpose,
+    run_cellpose,
+    is_gpu_availiable,
+    df_from_cellpose_mask,
+    load_sdh_model,
+    extract_single_image,
+)
 
 st.set_page_config(
     page_title="MyoQuant SDH Analysis",
     page_icon="🔬",
 )
 
-if path.exists("model.h5"):
-    st.success("SDH Model ready to use !")
-    pass
-else:
-    with st.spinner("Please wait we are downloading the SDH Model."):
-        urllib.request.urlretrieve(
-            "https://lbgi.fr/~meyer/SDH_models/model.h5", "model.h5"
-        )
-    st.success("SDH Model have been downloaded !")
-
-if len(list_physical_devices("GPU")) >= 1:
-    use_GPU = True
-else:
-    use_GPU = False
+use_GPU = is_gpu_availiable()
 
 
 @st.experimental_singleton
-def load_cellpose():
-    model_c = Cellpose(gpu=use_GPU, model_type="cyto2")
-    return model_c
+def st_load_sdh_model(model_path):
+    return load_sdh_model(model_path)
 
 
 @st.experimental_singleton
-def load_sdh_model():
-    model_sdh = keras.models.load_model(
-        "model.h5", custom_objects={"RandomBrightness": RandomBrightness}
-    )
-    return model_sdh
+def st_load_cellpose():
+    return load_cellpose()
 
 
 @st.experimental_memo
-def run_cellpose(image):
-    channel = [[0, 0]]
-    mask_cellpose, flow, style, diam = model_cellpose.eval(
-        image, diameter=None, channels=channel
-    )
-    return mask_cellpose
+def st_run_cellpose(image_ndarray, _model):
+    return run_cellpose(image_ndarray, _model)
 
 
 @st.experimental_memo
-def predict_single_cell(single_cell_img, _model_SDH):
-    img_array = np.empty((1, 256, 256, 3))
-    img_array[0] = tf.image.resize(single_cell_img, (256, 256))
-    prediction = _model_SDH.predict(img_array)
-    predicted_class = prediction.argmax()
-    predicted_proba = round(np.amax(prediction), 2)
-    heatmap = make_gradcam_heatmap(
-        img_array, _model_SDH.get_layer("resnet50v2"), "conv5_block3_3_conv"
-    )
-    grad_cam_img = save_and_display_gradcam(img_array[0], heatmap)
-    return grad_cam_img, predicted_class, predicted_proba
+def st_df_from_cellpose_mask(mask):
+    return df_from_cellpose_mask(mask)
 
 
 @st.experimental_memo
-def resize_batch_cells(histo_img, cellpose_df):
-    img_array_full = np.empty((len(cellpose_df), 256, 256, 3))
-    for index in range(len(cellpose_df)):
-        single_cell_img = histo_img[
-            cellpose_df.iloc[index, 5] : cellpose_df.iloc[index, 7],
-            cellpose_df.iloc[index, 6] : cellpose_df.iloc[index, 8],
-        ].copy()
+def st_predict_all_cells(image_ndarray, cellpose_df, _model_SDH):
+    return predict_all_cells(image_ndarray, cellpose_df, _model_SDH)
 
-        single_cell_mask = cellpose_df.iloc[index, 9].copy()
-        single_cell_img[~single_cell_mask] = 0
 
-        img_array_full[index] = tf.image.resize(single_cell_img, (256, 256))
-    return img_array_full
+@st.experimental_memo
+def st_extract_single_image(image_ndarray, cellpose_df, index):
+    return extract_single_image(image_ndarray, cellpose_df, index)
 
 
 @st.experimental_memo
-def predict_all_cells(histo_img, cellpose_df, _model_SDH):
-    predicted_class_array = np.empty((len(cellpose_df)))
-    predicted_proba_array = np.empty((len(cellpose_df)))
-    img_array_full = resize_batch_cells(histo_img, cellpose_df)
-    prediction = _model_SDH.predict(img_array_full)
-    index_counter = 0
-    for prediction_result in prediction:
-        predicted_class_array[index_counter] = prediction_result.argmax()
-        predicted_proba_array[index_counter] = np.amax(prediction_result)
-        index_counter += 1
-    return predicted_class_array, predicted_proba_array
+def st_predict_single_cell(image_ndarray, _model_SDH):
+    return predict_single_cell(image_ndarray, _model_SDH)
 
 
 @st.experimental_memo
-def paint_full_image(image_sdh, df_cellpose, class_predicted_all):
-    image_sdh_paint = np.zeros((image_sdh.shape[0], image_sdh.shape[1]), dtype=np.uint8)
-    for index in range(len(df_cellpose)):
-        single_cell_mask = df_cellpose.iloc[index, 9].copy()
-        if class_predicted_all[index] == 0:
-            image_sdh_paint[
-                df_cellpose.iloc[index, 5] : df_cellpose.iloc[index, 7],
-                df_cellpose.iloc[index, 6] : df_cellpose.iloc[index, 8],
-            ][single_cell_mask] = 1
-        elif class_predicted_all[index] == 1:
-            image_sdh_paint[
-                df_cellpose.iloc[index, 5] : df_cellpose.iloc[index, 7],
-                df_cellpose.iloc[index, 6] : df_cellpose.iloc[index, 8],
-            ][single_cell_mask] = 2
-    return image_sdh_paint
-
-
-model_cellpose = load_cellpose()
-
-model_SDH = load_sdh_model()
+def st_paint_full_image(image_sdh, df_cellpose, class_predicted_all):
+    return paint_full_image(image_sdh, df_cellpose, class_predicted_all)
+
+
+labels_predict = ["control", "sick"]
+
+tf.random.set_seed(42)
+np.random.seed(42)
+
+
+if path.exists("model.h5"):
+    st.success("SDH Model ready to use !")
+    pass
+else:
+    with st.spinner("Please wait we are downloading the SDH Model."):
+        urllib.request.urlretrieve(
+            "https://lbgi.fr/~meyer/SDH_models/model.h5", "model.h5"
+        )
+    st.success("SDH Model have been downloaded !")
+
+model_cellpose = st_load_cellpose()
+
+model_SDH = st_load_sdh_model("model.h5")
 
 st.title("SDH Staining Analysis")
 st.write(
@@ -149,7 +107,7 @@ if uploaded_file_sdh is not None:
     st.write("Raw Image")
     image = st.image(uploaded_file_sdh)
 
-    mask_cellpose = run_cellpose(image_ndarray_sdh)
+    mask_cellpose = st_run_cellpose(image_ndarray_sdh, model_cellpose)
 
     st.header("Segmentation Results")
     st.subheader("CellPose results")
@@ -158,35 +116,32 @@ if uploaded_file_sdh is not None:
     ax.axis("off")
     st.pyplot(fig)
 
-    st.subheader("All cells detected by CellPose")
-
-    props_cellpose = regionprops_table(
-        mask_cellpose,
-        properties=[
-            "label",
-            "area",
-            "centroid",
-            "eccentricity",
-            "bbox",
-            "image",
-            "perimeter",
-        ],
-    )
-    df_cellpose = pd.DataFrame(props_cellpose)
-    st.dataframe(df_cellpose.drop("image", axis=1))
-
     st.header("SDH Cell Classification Results")
-
-    class_predicted_all, proba_predicted_all = predict_all_cells(
+    df_cellpose = st_df_from_cellpose_mask(mask_cellpose)
+    df_cellpose_results = st_predict_all_cells(
         image_ndarray_sdh, df_cellpose, model_SDH
     )
-
+    class_predicted_all = df_cellpose_results["class_predicted"].values
+    proba_predicted_all = df_cellpose_results["proba_predicted"].values
     count_per_label = np.unique(class_predicted_all, return_counts=True)
     class_and_proba_df = pd.DataFrame(
         list(zip(class_predicted_all, proba_predicted_all)),
         columns=["class", "proba"],
     )
-    class_and_proba_df
+    st.dataframe(
+        df_cellpose_results.drop(
+            [
+                "centroid-0",
+                "centroid-1",
+                "bbox-0",
+                "bbox-1",
+                "bbox-2",
+                "bbox-3",
+                "image",
+            ],
+            axis=1,
+        )
+    )
     st.write("Total number of cells detected: ", len(class_predicted_all))
     for elem in count_per_label[0]:
         st.write(
@@ -202,15 +157,11 @@ if uploaded_file_sdh is not None:
     st.header("Single Cell Grad-CAM")
     selected_fiber = st.selectbox("Select a cell", list(range(len(df_cellpose))))
     selected_fiber = int(selected_fiber)
-    single_cell_img = image_ndarray_sdh[
-        df_cellpose.iloc[selected_fiber, 5] : df_cellpose.iloc[selected_fiber, 7],
-        df_cellpose.iloc[selected_fiber, 6] : df_cellpose.iloc[selected_fiber, 8],
-    ].copy()
-
-    single_cell_mask = df_cellpose.iloc[selected_fiber, 9].copy()
-    single_cell_img[~single_cell_mask] = 0
+    single_cell_img = st_extract_single_image(
+        image_ndarray_sdh, df_cellpose, selected_fiber
+    )
 
-    grad_img, class_predicted, proba_predicted = predict_single_cell(
+    grad_img, class_predicted, proba_predicted = st_predict_single_cell(
         single_cell_img, model_SDH
     )
 
@@ -234,7 +185,7 @@ if uploaded_file_sdh is not None:
     st.write(
         "Green color indicates cells classified as control, red color indicates cells classified as sick"
     )
-    paint_img = paint_full_image(image_ndarray_sdh, df_cellpose, class_predicted_all)
+    paint_img = st_paint_full_image(image_ndarray_sdh, df_cellpose, class_predicted_all)
     fig3, ax3 = plt.subplots(1, 1)
     cmap = matplotlib.colors.LinearSegmentedColormap.from_list(
         "", ["white", "green", "red"]
@@ -243,8 +194,9 @@ if uploaded_file_sdh is not None:
     ax3.imshow(paint_img, cmap=cmap, alpha=0.5)
     ax3.axis("off")
     st.pyplot(fig3)
+
 html(
     f"""
-    <script defer data-domain="huggingface.co/spaces/corentinm7/myoquant" src="https://plausible.cmeyer.fr/js/script.js"></script>
+    <script defer data-domain="lbgi.fr/myoquant" src="https://plausible.cmeyer.fr/js/script.js"></script>
     """
-)
+)

pages/3_Breast_Muscle_Analysis.py

@@ -1,205 +1,110 @@
 import streamlit as st
 from streamlit.components.v1 import html
-from cellpose import models, core
-from stardist.models import StarDist2D
-from csbdeep.utils import normalize
 import matplotlib
 
 try:
     from imageio.v2 import imread
 except:
     from imageio import imread
-from skimage.measure import regionprops_table
-import pandas as pd
 import matplotlib.pyplot as plt
 from stardist import random_label_cmap
-from tensorflow.config import list_physical_devices
-from draw_line import *
-from skimage.draw import line
 import numpy as np
 
+from myoquant.src.common_func import (
+    load_cellpose,
+    load_stardist,
+    run_cellpose,
+    run_stardist,
+    is_gpu_availiable,
+    df_from_cellpose_mask,
+    df_from_stardist_mask,
+)
+from myoquant.src.HE_analysis import (
+    predict_all_cells,
+    extract_ROIs,
+    single_cell_analysis,
+    paint_histo_img,
+)
+
+
 st.set_page_config(
     page_title="MyoQuant Breast Analysis",
     page_icon="🔬",
 )
 
-if len(list_physical_devices("GPU")) >= 1:
-    use_GPU = True
-else:
-    use_GPU = False
+use_GPU = is_gpu_availiable()
 
 
 @st.experimental_singleton
-def load_cellpose():
-    model_c = models.Cellpose(gpu=use_GPU, model_type="cyto2")
-    return model_c
+def st_load_cellpose():
+    return load_cellpose()
 
 
 @st.experimental_singleton
-def load_stardist_fluo():
-    model_s_fluo = StarDist2D.from_pretrained("2D_versatile_fluo")
-    return model_s_fluo
+def st_load_stardist(fluo=False):
+    return load_stardist(fluo)
 
 
 @st.experimental_memo
-def run_cellpose(image):
-    channel = [[0, 0]]
-    mask_cellpose, flow, style, diam = model_cellpose.eval(
-        image, diameter=None, channels=channel
-    )
-    return mask_cellpose
+def st_run_cellpose(image_ndarray, _model):
+    return run_cellpose(image_ndarray, _model)
 
 
 @st.experimental_memo
-def run_stardist(image, nms_thresh=0.4, prob_thresh=0.5):
-    img_norm = image / 255
-    img_norm = normalize(img_norm, 1, 99.8)
-    mask_stardist, _ = model_stardist_fluo.predict_instances(
-        img_norm, nms_thresh=nms_thresh, prob_thresh=prob_thresh
-    )
-    return mask_stardist
+def st_run_stardist(image_ndarray, _model, nms_thresh, prob_thresh):
+    return run_stardist(image_ndarray, _model, nms_thresh, prob_thresh)
 
 
 @st.experimental_memo
-def extract_ROIs(histo_img, index, cellpose_df, mask_stardist):
-    single_cell_img = histo_img[
-        cellpose_df.iloc[index, 5] : cellpose_df.iloc[index, 7],
-        cellpose_df.iloc[index, 6] : cellpose_df.iloc[index, 8],
-    ].copy()
-    nucleus_single_cell_img = mask_stardist[
-        cellpose_df.iloc[index, 5] : cellpose_df.iloc[index, 7],
-        cellpose_df.iloc[index, 6] : cellpose_df.iloc[index, 8],
-    ].copy()
-    single_cell_mask = cellpose_df.iloc[index, 9]
-    single_cell_img[~single_cell_mask] = 0
-    nucleus_single_cell_img[~single_cell_mask] = 0
+def st_df_from_cellpose_mask(mask):
+    return df_from_cellpose_mask(mask)
 
-    props_nuc_single = regionprops_table(
-        nucleus_single_cell_img,
-        intensity_image=single_cell_img,
-        properties=[
-            "label",
-            "area",
-            "centroid",
-            "eccentricity",
-            "bbox",
-            "image",
-            "perimeter",
-        ],
-    )
-    df_nuc_single = pd.DataFrame(props_nuc_single)
-    return single_cell_img, nucleus_single_cell_img, single_cell_mask, df_nuc_single
+
+@st.experimental_memo
+def st_df_from_stardist_mask(mask):
+    return df_from_stardist_mask(mask)
 
 
 @st.experimental_memo
-def single_cell_analysis(
-    single_cell_img,
-    single_cell_mask,
-    df_nuc_single,
-    x_fiber,
-    y_fiber,
-    internalised_threshold=0.75,
+def st_predict_all_cells(
+    image_ndarray, df_cellpose, mask_stardist, internalised_threshold
 ):
-    n_nuc, n_nuc_intern, n_nuc_periph = 0, 0, 0
-    for _, value in df_nuc_single.iterrows():
-        n_nuc += 1
-        # Extend line and find closest point
-        m, b = line_equation(x_fiber, y_fiber, value[3], value[2])
-
-        intersections_lst = calculate_intersection(
-            m, b, (single_cell_img.shape[0], single_cell_img.shape[1])
-        )
-        border_point = calculate_closest_point(value[3], value[2], intersections_lst)
-        rr, cc = line(
-            int(y_fiber),
-            int(x_fiber),
-            int(border_point[1]),
-            int(border_point[0]),
-        )
-        for index3, coords in enumerate(list(zip(rr, cc))):
-            try:
-                if single_cell_mask[coords] == 0:
-                    dist_nuc_cent = calculate_distance(
-                        x_fiber, y_fiber, value[3], value[2]
-                    )
-                    dist_out_of_fiber = calculate_distance(
-                        x_fiber, y_fiber, coords[1], coords[0]
-                    )
-                    ratio_dist = dist_nuc_cent / dist_out_of_fiber
-                    if ratio_dist < internalised_threshold:
-                        n_nuc_intern += 1
-                    else:
-                        n_nuc_periph += 1
-                    break
-            except IndexError:
-                coords = list(zip(rr, cc))[index3 - 1]
-                dist_nuc_cent = calculate_distance(x_fiber, y_fiber, value[3], value[2])
-                dist_out_of_fiber = calculate_distance(
-                    x_fiber, y_fiber, coords[1], coords[0]
-                )
-                ratio_dist = dist_nuc_cent / dist_out_of_fiber
-                if ratio_dist < internalised_threshold:
-                    n_nuc_intern += 1
-                else:
-                    n_nuc_periph += 1
-                break
-
-    return n_nuc, n_nuc_intern, n_nuc_periph
+    return predict_all_cells(
+        image_ndarray, df_cellpose, mask_stardist, internalised_threshold
+    )
 
 
 @st.experimental_memo
-def predict_all_cells(
-    histo_img, cellpose_df, mask_stardist, internalised_threshold=0.75
-):
-    list_n_nuc, list_n_nuc_intern, list_n_nuc_periph = [], [], []
-    for index in range(len(cellpose_df)):
-        (
-            single_cell_img,
-            _,
-            single_cell_mask,
-            df_nuc_single,
-        ) = extract_ROIs(histo_img, index, cellpose_df, mask_stardist)
-        x_fiber = cellpose_df.iloc[index, 3] - cellpose_df.iloc[index, 6]
-        y_fiber = cellpose_df.iloc[index, 2] - cellpose_df.iloc[index, 5]
-        n_nuc, n_nuc_intern, n_nuc_periph = single_cell_analysis(
-            single_cell_img,
-            single_cell_mask,
-            df_nuc_single,
-            x_fiber,
-            y_fiber,
-            internalised_threshold,
-        )
-        list_n_nuc.append(n_nuc)
-        list_n_nuc_intern.append(n_nuc_intern)
-        list_n_nuc_periph.append(n_nuc_periph)
-        df_nuc_analysis = pd.DataFrame(
-            list(zip(list_n_nuc, list_n_nuc_intern, list_n_nuc_periph)),
-            columns=["N° Nuc", "N° Nuc Intern", "N° Nuc Periph"],
-        )
-    return df_nuc_analysis
+def st_extract_ROIs(image_ndarray, selected_fiber, df_cellpose, mask_stardist):
+    return extract_ROIs(image_ndarray, selected_fiber, df_cellpose, mask_stardist)
 
 
 @st.experimental_memo
-def predict_single_cell(histo_img, cellpose_df, mask_stardist):
-    pass
+def st_single_cell_analysis(
+    single_cell_img,
+    single_cell_mask,
+    df_nuc_single,
+    x_fiber,
+    y_fiber,
+    selected_fiber,
+    internalised_threshold,
+    draw_and_return=True,
+):
+    return single_cell_analysis(
+        single_cell_img,
+        single_cell_mask,
+        df_nuc_single,
+        x_fiber,
+        y_fiber,
+        selected_fiber + 1,
+        internalised_threshold,
+        draw_and_return=True,
+    )
 
 
 @st.experimental_memo
-def paint_histo_img(histo_img, cellpose_df, prediction_df):
-    paint_img = np.zeros((histo_img.shape[0], histo_img.shape[1]), dtype=np.uint8)
-    for index in range(len(cellpose_df)):
-        single_cell_mask = cellpose_df.iloc[index, 9].copy()
-        if prediction_df.iloc[index, 1] == 0:
-            paint_img[
-                cellpose_df.iloc[index, 5] : cellpose_df.iloc[index, 7],
-                cellpose_df.iloc[index, 6] : cellpose_df.iloc[index, 8],
-            ][single_cell_mask] = 1
-        elif prediction_df.iloc[index, 1] > 0:
-            paint_img[
-                cellpose_df.iloc[index, 5] : cellpose_df.iloc[index, 7],
-                cellpose_df.iloc[index, 6] : cellpose_df.iloc[index, 8],
-            ][single_cell_mask] = 2
-    return paint_img
+def st_paint_histo_img(image_ndarray, df_cellpose, cellpose_df_stat):
+    return paint_histo_img(image_ndarray, df_cellpose, cellpose_df_stat)
 
 
 with st.sidebar:
@@ -207,10 +112,10 @@ with st.sidebar:
     nms_thresh = st.slider("Stardist NMS Tresh", 0.0, 1.0, 0.4, 0.1)
     prob_thresh = st.slider("Stardist Prob Tresh", 0.5, 1.0, 0.5, 0.05)
     st.write("Nuclei Classification Parameter")
-    center_thresh = st.slider("Eccentricity Score Tresh", 0.0, 1.0, 0.75, 0.05)
+    eccentricity_thresh = st.slider("Eccentricity Score Tresh", 0.0, 1.0, 0.75, 0.05)
 
-model_cellpose = load_cellpose()
-model_stardist_fluo = load_stardist_fluo()
+model_cellpose = st_load_cellpose()
+model_stardist = st_load_stardist(fluo=True)
 
 st.title("Breast Muscle Fiber Analysis")
 st.write(
@@ -231,8 +136,10 @@ if uploaded_file_cyto is not None and uploaded_file_nuc is not None:
     st.write("Raw Image Nuc")
     image_nuc = st.image(image_ndarray_nuc)
 
-    mask_cellpose = run_cellpose(image_ndarray_cyto)
-    mask_stardist = run_stardist(image_ndarray_nuc, nms_thresh, prob_thresh)
+    mask_cellpose = st_run_cellpose(image_ndarray_cyto, model_cellpose)
+    mask_stardist = st_run_stardist(
+        image_ndarray_nuc, model_stardist, nms_thresh, prob_thresh
+    )
     mask_stardist_copy = mask_stardist.copy()
 
     st.header("Segmentation Results")
@@ -244,60 +151,61 @@ if uploaded_file_cyto is not None and uploaded_file_nuc is not None:
     ax.axis("off")
     st.pyplot(fig)
 
-    st.subheader("All cells detected by CellPose")
-    props_cellpose = regionprops_table(
-        mask_cellpose,
-        properties=[
-            "label",
-            "area",
-            "centroid",
-            "eccentricity",
-            "bbox",
-            "image",
-            "perimeter",
-        ],
-    )
-    df_cellpose = pd.DataFrame(props_cellpose)
-    st.dataframe(df_cellpose.drop("image", axis=1))
-
     st.header("Full Nucleus Analysis Results")
-    df_nuc_analysis = predict_all_cells(
-        image_ndarray_cyto, df_cellpose, mask_stardist, center_thresh
+    df_cellpose = st_df_from_cellpose_mask(mask_cellpose)
+    cellpose_df_stat, all_nuc_df_stats = st_predict_all_cells(
+        image_ndarray_cyto,
+        df_cellpose,
+        mask_stardist,
+        internalised_threshold=eccentricity_thresh,
+    )
+    st.dataframe(
+        cellpose_df_stat.drop(
+            [
+                "centroid-0",
+                "centroid-1",
+                "bbox-0",
+                "bbox-1",
+                "bbox-2",
+                "bbox-3",
+                "image",
+            ],
+            axis=1,
+        )
     )
-    st.dataframe(df_nuc_analysis)
-    st.write("Total number of nucleus : ", df_nuc_analysis["N° Nuc"].sum())
+    st.write("Total number of nucleus : ", cellpose_df_stat["N° Nuc"].sum())
     st.write(
         "Total number of internalized nucleus : ",
-        df_nuc_analysis["N° Nuc Intern"].sum(),
+        cellpose_df_stat["N° Nuc Intern"].sum(),
         " (",
         round(
             100
-            * df_nuc_analysis["N° Nuc Intern"].sum()
-            / df_nuc_analysis["N° Nuc"].sum(),
+            * cellpose_df_stat["N° Nuc Intern"].sum()
+            / cellpose_df_stat["N° Nuc"].sum(),
             2,
         ),
         "%)",
     )
     st.write(
         "Total number of peripherical nucleus : ",
-        df_nuc_analysis["N° Nuc Periph"].sum(),
+        cellpose_df_stat["N° Nuc Periph"].sum(),
         " (",
         round(
             100
-            * df_nuc_analysis["N° Nuc Periph"].sum()
-            / df_nuc_analysis["N° Nuc"].sum(),
+            * cellpose_df_stat["N° Nuc Periph"].sum()
+            / cellpose_df_stat["N° Nuc"].sum(),
             2,
         ),
         "%)",
     )
     st.write(
         "Number of cell with at least one internalized nucleus : ",
-        df_nuc_analysis["N° Nuc Intern"].astype(bool).sum(axis=0),
+        cellpose_df_stat["N° Nuc Intern"].astype(bool).sum(axis=0),
         " (",
         round(
             100
-            * df_nuc_analysis["N° Nuc Intern"].astype(bool).sum(axis=0)
-            / len(df_nuc_analysis),
+            * cellpose_df_stat["N° Nuc Intern"].astype(bool).sum(axis=0)
+            / len(cellpose_df_stat),
             2,
         ),
         "%)",
@@ -317,20 +225,13 @@ if uploaded_file_cyto is not None and uploaded_file_nuc is not None:
     single_cell_img[~single_cell_mask] = 0
     nucleus_single_cell_img[~single_cell_mask] = 0
 
-    props_nuc_single = regionprops_table(
+    (
+        single_cell_img,
         nucleus_single_cell_img,
-        intensity_image=single_cell_img,
-        properties=[
-            "label",
-            "area",
-            "centroid",
-            "eccentricity",
-            "bbox",
-            "image",
-            "perimeter",
-        ],
-    )
-    df_nuc_single = pd.DataFrame(props_nuc_single)
+        single_cell_mask,
+        df_nuc_single,
+    ) = st_extract_ROIs(mergedarrays, selected_fiber, df_cellpose, mask_stardist)
+
     st.markdown(
         """
         * White point represent cell centroid. 
@@ -338,83 +239,63 @@ if uploaded_file_cyto is not None and uploaded_file_nuc is not None:
         * Red point represent the cell border from a straight line between the cell centroid and the nucleus centroid. The red dashed line represent distance between the nucelus and the cell border. 
         * The periphery ratio is calculated by the division of the distance centroid - nucleus and the distance centroid - cell border."""
     )
-    fig2, (ax1, ax2, ax3) = plt.subplots(1, 3)
+    fig2, (ax1, ax2) = plt.subplots(1, 2)
     ax1.imshow(single_cell_img, cmap="gray")
     ax2.imshow(nucleus_single_cell_img, cmap="viridis")
     # Plot Fiber centroid
     x_fiber = df_cellpose.iloc[selected_fiber, 3] - df_cellpose.iloc[selected_fiber, 6]
     y_fiber = df_cellpose.iloc[selected_fiber, 2] - df_cellpose.iloc[selected_fiber, 5]
-    ax3.scatter(x_fiber, y_fiber, color="white")
-    # Plot nucleus centroid
-    for index, value in df_nuc_single.iterrows():
-        ax3.scatter(value[3], value[2], color="blue", s=2)
-        # Extend line and find closest point
-        m, b = line_equation(x_fiber, y_fiber, value[3], value[2])
-
-        intersections_lst = calculate_intersection(
-            m, b, (single_cell_img.shape[0], single_cell_img.shape[1])
-        )
-        border_point = calculate_closest_point(value[3], value[2], intersections_lst)
-        ax3.plot(
-            (x_fiber, border_point[0]),
-            (y_fiber, border_point[1]),
-            "ro--",
-            linewidth=1,
-            markersize=1,
-        )
-        ax3.plot(
-            (x_fiber, value[3]),
-            (y_fiber, value[2]),
-            "go--",
-            linewidth=1,
-            markersize=1,
-        )
 
-        rr, cc = line(
-            int(y_fiber),
-            int(x_fiber),
-            int(border_point[1]),
-            int(border_point[0]),
-        )
-        for index, coords in enumerate(list(zip(rr, cc))):
-            try:
-                if single_cell_mask[coords] == 0:
-                    dist_nuc_cent = calculate_distance(
-                        x_fiber, y_fiber, value[3], value[2]
-                    )
-                    dist_out_of_fiber = calculate_distance(
-                        x_fiber, y_fiber, coords[1], coords[0]
-                    )
-                    ratio_dist = dist_nuc_cent / dist_out_of_fiber
-                    ax3.scatter(coords[1], coords[0], color="red", s=10)
-                    break
-            except IndexError:
-                coords = list(zip(rr, cc))[index - 1]
-                dist_nuc_cent = calculate_distance(x_fiber, y_fiber, value[3], value[2])
-                dist_out_of_fiber = calculate_distance(
-                    x_fiber, y_fiber, coords[1], coords[0]
-                )
-                ratio_dist = dist_nuc_cent / dist_out_of_fiber
-                ax3.scatter(coords[1], coords[0], color="red", s=10)
-                break
-
-        st.write("Nucleus #{} has a periphery ratio of: {}".format(index, ratio_dist))
-    ax3.imshow(single_cell_img)
-    ax3.imshow(nucleus_single_cell_img, cmap="viridis", alpha=0.5)
+    (
+        n_nuc,
+        n_nuc_intern,
+        n_nuc_periph,
+        df_nuc_single_stats,
+        ax_nuc,
+    ) = st_single_cell_analysis(
+        single_cell_img,
+        single_cell_mask,
+        df_nuc_single,
+        x_fiber,
+        y_fiber,
+        selected_fiber + 1,
+        internalised_threshold=eccentricity_thresh,
+        draw_and_return=True,
+    )
+
+    for index, value in df_nuc_single_stats.iterrows():
+        st.write("Nucleus #{} has a periphery ratio of: {}".format(index, value[12]))
     ax1.axis("off")
     ax2.axis("off")
-    ax3.axis("off")
-    st.pyplot(fig2)
+    # st.pyplot(fig2)
+    ax_nuc.imshow(single_cell_img)
+    ax_nuc.imshow(nucleus_single_cell_img, cmap="viridis", alpha=0.5)
+    f = ax_nuc.figure
 
+    st.pyplot(fig2)
+    st.pyplot(f)
     st.subheader("All nucleus inside selected cell")
 
-    st.dataframe(df_nuc_single.drop("image", axis=1))
+    st.dataframe(
+        df_nuc_single_stats.drop(
+            [
+                "centroid-0",
+                "centroid-1",
+                "bbox-0",
+                "bbox-1",
+                "bbox-2",
+                "bbox-3",
+                "image",
+            ],
+            axis=1,
+        )
+    )
 
     st.header("Painted predicted image")
     st.write(
         "Green color indicates cells with only peripherical nuclei, red color indicates cells with at least one internal nucleus (regeneration)."
     )
-    painted_img = paint_histo_img(image_ndarray_cyto, df_cellpose, df_nuc_analysis)
+    painted_img = st_paint_histo_img(image_ndarray_cyto, df_cellpose, cellpose_df_stat)
     fig3, ax3 = plt.subplots(1, 1)
     cmap = matplotlib.colors.LinearSegmentedColormap.from_list(
         "", ["white", "green", "red"]
@@ -423,8 +304,9 @@ if uploaded_file_cyto is not None and uploaded_file_nuc is not None:
     ax3.imshow(painted_img, cmap=cmap, alpha=0.5)
     ax3.axis("off")
     st.pyplot(fig3)
+
 html(
     f"""
-    <script defer data-domain="huggingface.co/spaces/corentinm7/myoquant" src="https://plausible.cmeyer.fr/js/script.js"></script>
+    <script defer data-domain="lbgi.fr/myoquant" src="https://plausible.cmeyer.fr/js/script.js"></script>
     """
 )

pages/4_ATP_Staining_Analysis.py

@@ -0,0 +1,171 @@
+import streamlit as st
+from streamlit.components.v1 import html
+import matplotlib
+
+try:
+    from imageio.v2 import imread
+except:
+    from imageio import imread
+import matplotlib.pyplot as plt
+import pandas as pd
+import numpy as np
+from myoquant.src.common_func import (
+    load_cellpose,
+    run_cellpose,
+    is_gpu_availiable,
+    df_from_cellpose_mask,
+)
+from myoquant.src.ATP_analysis import (
+    get_all_intensity,
+    estimate_threshold,
+    plot_density,
+    predict_all_cells,
+    paint_full_image,
+)
+
+labels_predict = {1: "fiber type 1", 2: "fiber type 2"}
+
+use_GPU = is_gpu_availiable()
+np.random.seed(42)
+
+st.set_page_config(
+    page_title="MyoQuant ATP Analysis",
+    page_icon="🔬",
+)
+
+
+@st.experimental_singleton
+def st_load_cellpose():
+    return load_cellpose()
+
+
+@st.experimental_memo
+def st_run_cellpose(image_atp, _model):
+    return run_cellpose(image_atp, _model)
+
+
+@st.experimental_memo
+def st_df_from_cellpose_mask(mask):
+    return df_from_cellpose_mask(mask)
+
+
+@st.experimental_memo
+def st_get_all_intensity(image_atp, df_cellpose):
+    return get_all_intensity(image_atp, df_cellpose)
+
+
+@st.experimental_memo
+def st_estimate_threshold(intensity_list):
+    return estimate_threshold(intensity_list)
+
+
+@st.experimental_memo
+def st_plot_density(all_cell_median_intensity, intensity_threshold):
+    return plot_density(all_cell_median_intensity, intensity_threshold)
+
+
+@st.experimental_memo
+def st_predict_all_cells(image_atp, cellpose_df, intensity_threshold):
+    return predict_all_cells(image_atp, cellpose_df, intensity_threshold)
+
+
+@st.experimental_memo
+def st_paint_full_image(image_atp, df_cellpose, class_predicted_all):
+    return paint_full_image(image_atp, df_cellpose, class_predicted_all)
+
+
+model_cellpose = st_load_cellpose()
+
+with st.sidebar:
+    st.write("Threshold Parameters")
+    intensity_threshold = st.slider("Intensity Threshold (0=auto)", 0, 255, 0, 5)
+
+st.title("ATP Staining Analysis")
+st.write(
+    "This demo will automatically quantify the number of type 1 muscle fibers vs the number of type 2 muscle fiber on ATP stained images."
+)
+st.write("Upload your ATP Staining image")
+uploaded_file_atp = st.file_uploader("Choose a file")
+
+if uploaded_file_atp is not None:
+    image_ndarray_atp = imread(uploaded_file_atp)
+
+    st.write("Raw Image")
+    image = st.image(uploaded_file_atp)
+
+    mask_cellpose = st_run_cellpose(image_ndarray_atp, model_cellpose)
+
+    st.header("Segmentation Results")
+    st.subheader("CellPose results")
+    fig, ax = plt.subplots(1, 1)
+    ax.imshow(mask_cellpose, cmap="viridis")
+    ax.axis("off")
+    st.pyplot(fig)
+
+    df_cellpose = st_df_from_cellpose_mask(mask_cellpose)
+
+    st.header("Cell Intensity Plot")
+    all_cell_median_intensity = st_get_all_intensity(image_ndarray_atp, df_cellpose)
+    figure_intensity = st_plot_density(all_cell_median_intensity, intensity_threshold)
+    st.pyplot(figure_intensity)
+
+    st.header("ATP Cell Classification Results")
+    if intensity_threshold == 0:
+        muscle_fiber_type_all, all_cell_median_intensity = st_predict_all_cells(
+            image_ndarray_atp, df_cellpose, intensity_threshold=None
+        )
+    else:
+        muscle_fiber_type_all, all_cell_median_intensity = st_predict_all_cells(
+            image_ndarray_atp, df_cellpose, intensity_threshold=intensity_threshold
+        )
+    df_cellpose["muscle_fiber_type"] = muscle_fiber_type_all
+    df_cellpose["median_intensity"] = all_cell_median_intensity
+    count_per_label = np.unique(muscle_fiber_type_all, return_counts=True)
+
+    st.dataframe(
+        df_cellpose.drop(
+            [
+                "centroid-0",
+                "centroid-1",
+                "bbox-0",
+                "bbox-1",
+                "bbox-2",
+                "bbox-3",
+                "image",
+            ],
+            axis=1,
+        )
+    )
+    st.write("Total number of cells detected: ", len(muscle_fiber_type_all))
+    for index, elem in enumerate(count_per_label[0]):
+        st.write(
+            "Number of cells classified as ",
+            labels_predict[int(elem)],
+            ": ",
+            count_per_label[1][int(index)],
+            " ",
+            100 * count_per_label[1][int(index)] / len(muscle_fiber_type_all),
+            "%",
+        )
+
+    st.header("Painted predicted image")
+    st.write(
+        "Green color indicates cells classified as control, red color indicates cells classified as sick"
+    )
+    paint_img = st_paint_full_image(
+        image_ndarray_atp, df_cellpose, muscle_fiber_type_all
+    )
+    fig3, ax3 = plt.subplots(1, 1)
+    cmap = matplotlib.colors.LinearSegmentedColormap.from_list(
+        "", ["white", "green", "red"]
+    )
+    ax3.imshow(image_ndarray_atp)
+    ax3.imshow(paint_img, cmap=cmap, alpha=0.5)
+    ax3.axis("off")
+    st.pyplot(fig3)
+
+html(
+    f"""
+    <script defer data-domain="lbgi.fr/myoquant" src="https://plausible.cmeyer.fr/js/script.js"></script>
+    """
+)

pyproject.toml

@@ -1,23 +1,29 @@
 [tool.poetry]
 name = "MyoQuant-Streamlit"
-version = "0.1.0"
+version = "0.3.0"
 description = "Streamlit demo version of the MyoQuant tool"
 authors = ["Corentin"]
 license = "AGPL"
 
 [tool.poetry.dependencies]
-python = ">=3.9,<3.11"
-tensorflow = "^2.9.1"
-cellpose = "^2.1.0"
-stardist = "^0.8.3"
+python = ">=3.8,<3.11"
+myoquant = "^0.3.1"
 streamlit = "^1.12.0"
-csbdeep = "^0.7.2"
+pyngrok = "^5.1.0"
 imageio = "^2.21.1"
-scikit-image = "^0.19.3"
 pandas = "^1.4.3"
 matplotlib = "^3.5.3"
+ipykernel = "^6.15.1"
 
-[tool.poetry.dev-dependencies]
+[tool.poetry.group.dev.dependencies]
+ruff = "*"
+mkdocs-material = "*"
+black = {extras = ["jupyter"], version = "*"}
+ipykernel = "*"
+pytest = "*"
+pre-commit = "*"
+mypy = "*"
+mkdocstrings = "*"
 
 [build-system]
 requires = ["poetry-core>=1.0.0"]