starting the merge with streamlit version

Author: Corentin

myoquant/commands/run_sdh.py

@@ -164,21 +164,23 @@ def sdh_analysis(
         progress.add_task(description="Reading all inputs...", total=None)
         image_ndarray_sdh = imread(image_path)
 
-    if mask_path is not None:
-        mask_ndarray = imread(mask_path)
-        if np.unique(mask_ndarray).shape[0] != 2:
-            console.print(
-                "The mask image should be a binary image with only 2 values (0 and 1).",
-                style="red",
-            )
-            raise ValueError
-        if len(image_ndarray_sdh.shape) > 2:
-            mask_ndarray = np.repeat(
-                mask_ndarray.reshape(mask_ndarray.shape[0], mask_ndarray.shape[1], 1),
-                image_ndarray_sdh.shape[2],
-                axis=2,
-            )
-        image_ndarray_sdh = image_ndarray_sdh * mask_ndarray
+        if mask_path is not None:
+            mask_ndarray = imread(mask_path)
+            if np.unique(mask_ndarray).shape[0] != 2:
+                console.print(
+                    "The mask image should be a binary image with only 2 values (0 and 1).",
+                    style="red",
+                )
+                raise ValueError
+            if len(image_ndarray_sdh.shape) > 2:
+                mask_ndarray = np.repeat(
+                    mask_ndarray.reshape(
+                        mask_ndarray.shape[0], mask_ndarray.shape[1], 1
+                    ),
+                    image_ndarray_sdh.shape[2],
+                    axis=2,
+                )
+            image_ndarray_sdh = image_ndarray_sdh * mask_ndarray
         if cellpose_path is not None:
             mask_cellpose = imread(cellpose_path)
 

myoquant/src/ATP_analysis.py

@@ -44,6 +44,25 @@ def estimate_threshold(intensity_list):
     return threshold
 
 
+def plot_density(all_cell_median_intensity, intensity_threshold):
+    if intensity_threshold == 0:
+        intensity_threshold = estimate_threshold(all_cell_median_intensity)
+    fig, ax = plt.subplots(figsize=(10, 5))
+    density = gaussian_kde(all_cell_median_intensity)
+    density.covariance_factor = lambda: 0.25
+    density._compute_covariance()
+
+    # Create a vector of 256 values going from 0 to 256:
+    xs = np.linspace(0, 255, 256)
+    density_xs_values = density(xs)
+    ax.plot(xs, density_xs_values, label="Estimated Density")
+    ax.axvline(x=intensity_threshold, color="red", label="Threshold")
+    ax.set_xlabel("Pixel Intensity")
+    ax.set_ylabel("Density")
+    ax.legend()
+    return fig
+
+
 def predict_all_cells(histo_img, cellpose_df, intensity_threshold):
     all_cell_median_intensity = get_all_intensity(histo_img, cellpose_df)
     if intensity_threshold is None:

myoquant/src/HE_analysis.py

@@ -45,6 +45,7 @@ def single_cell_analysis(
     y_fiber,
     cell_label,
     internalised_threshold=0.75,
+    draw_and_return=False,
 ):
     n_nuc, n_nuc_intern, n_nuc_periph = 0, 0, 0
     new_row_lst = []

myoquant/src/SDH_analysis.py

@@ -4,9 +4,7 @@
 
 import pandas as pd
 import tensorflow as tf
-from rich.progress import track
-from skimage.measure import regionprops_table
-
+from .common_func import extract_single_image, df_from_cellpose_mask
 from .gradcam import make_gradcam_heatmap, save_and_display_gradcam
 import numpy as np
 
@@ -32,14 +30,7 @@ def resize_batch_cells(histo_img, cellpose_df):
     img_array_full = np.empty((len(cellpose_df), 256, 256, 3))
     # for index in track(range(len(cellpose_df)), description="Resizing cells"):
     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()
-
-        single_cell_mask = cellpose_df.iloc[index, 9].copy()
-        single_cell_img[~single_cell_mask] = 0
-
+        single_cell_img = extract_single_image(histo_img, cellpose_df, index)
         img_array_full[index] = tf.image.resize(single_cell_img, (256, 256))
     return img_array_full
 
@@ -54,7 +45,9 @@ def predict_all_cells(histo_img, cellpose_df, _model_SDH):
         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
+    cellpose_df["class_predicted"] = predicted_class_array
+    cellpose_df["proba_predicted"] = predicted_proba_array
+    return cellpose_df
 
 
 def paint_full_image(image_sdh, df_cellpose, class_predicted_all):
@@ -78,43 +71,28 @@ def paint_full_image(image_sdh, df_cellpose, class_predicted_all):
 
 
 def run_sdh_analysis(image_array, model_SDH, mask_cellpose):
-    props_cellpose = regionprops_table(
-        mask_cellpose,
-        properties=[
-            "label",
-            "area",
-            "centroid",
-            "eccentricity",
-            "bbox",
-            "image",
-            "perimeter",
-        ],
-    )
-    df_cellpose = pd.DataFrame(props_cellpose)
-    class_predicted_all, proba_predicted_all = predict_all_cells(
-        image_array, df_cellpose, model_SDH
-    )
-    df_cellpose["class_predicted"] = class_predicted_all
-    df_cellpose["proba_predicted"] = proba_predicted_all
-    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"],
-    )
+    df_cellpose = df_from_cellpose_mask(mask_cellpose)
+
+    df_cellpose = predict_all_cells(image_array, df_cellpose, model_SDH)
+    count_per_label = np.unique(df_cellpose["class_predicted"], return_counts=True)
 
     # Result table dict
     headers = ["Feature", "Raw Count", "Proportion (%)"]
     data = []
-    data.append(["Muscle Fibers", len(class_predicted_all), 100])
+    data.append(["Muscle Fibers", len(df_cellpose["class_predicted"]), 100])
     for elem in count_per_label[0]:
         data.append(
             [
                 labels_predict[int(elem)],
                 count_per_label[1][int(elem)],
-                100 * count_per_label[1][int(elem)] / len(class_predicted_all),
+                100
+                * count_per_label[1][int(elem)]
+                / len(df_cellpose["class_predicted"]),
             ]
         )
     result_df = pd.DataFrame(columns=headers, data=data)
     # Paint The Full Image
-    full_label_map = paint_full_image(image_array, df_cellpose, class_predicted_all)
+    full_label_map = paint_full_image(
+        image_array, df_cellpose, df_cellpose["class_predicted"]
+    )
     return result_df, full_label_map, df_cellpose

myoquant/src/common_func.py

@@ -130,6 +130,51 @@ def run_stardist(image, model_stardist, nms_thresh=0.4, prob_thresh=0.5):
     return mask_stardist
 
 
+def df_from_cellpose_mask(mask):
+    props_cellpose = regionprops_table(
+        mask,
+        properties=[
+            "label",
+            "area",
+            "centroid",
+            "eccentricity",
+            "bbox",
+            "image",
+            "perimeter",
+            "feret_diameter_max",
+        ],
+    )
+    df_cellpose = pd.DataFrame(props_cellpose)
+    return df_cellpose
+
+
+def df_from_stardist_mask(mask):
+    props_stardist = regionprops_table(
+        mask,
+        properties=[
+            "label",
+            "area",
+            "centroid",
+            "eccentricity",
+            "bbox",
+            "image",
+            "perimeter",
+        ],
+    )
+    df_stardist = pd.DataFrame(props_stardist)
+    return df_stardist
+
+
+def extract_single_image(raw_image, df_props, index):
+    single_entity_img = raw_image[
+        df_props.iloc[index, 5] : df_props.iloc[index, 7],
+        df_props.iloc[index, 6] : df_props.iloc[index, 8],
+    ].copy()
+    single_entity_mask = df_props.iloc[index, 9]
+    single_entity_img[~single_entity_mask] = 0
+    return single_entity_img
+
+
 def label2rgb(img_ndarray, label_map):
     """Convert a label map to RGB image