code_propre.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing all necessary package\n",
    "import os\n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "\n",
    "\n",
    "os.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"3\"\n",
    "\n",
    "#A generalist algorithm for cell and nucleus segmentation (v1.0) that can be optimized for your own data (v2.0)\n",
    "from cellpose.models import Cellpose \n",
    "from stardist.models import StarDist2D\n",
    "\n",
    "from csbdeep.utils import normalize\n",
    "\n",
    "import tensorflow as tf\n",
    "\n",
    "from tensorflow import keras\n",
    "from tensorflow.config import list_physical_devices\n",
    "\n",
    "# Setting the random seed for reproducibility\n",
    "tf.random.set_seed(42)\n",
    "np.random.seed(42)\n",
    "\n",
    "# Check if GPU is available\n",
    "if len(list_physical_devices(\"GPU\")) >= 1:\n",
    "    use_GPU = True\n",
    "    tf.config.experimental.set_memory_growth(list_physical_devices(\"GPU\")[0], True)\n",
    "\n",
    "else:\n",
    "    use_GPU = False\n",
    "\n",
    "def load_cellpose():\n",
    "    \"\"\"Load the cellpose model and return it\"\"\"\n",
    "    model_c = Cellpose(gpu=use_GPU, model_type=\"cyto2\")\n",
    "    return model_c\n",
    "\n",
    "\n",
    "def load_stardist():\n",
    "    \"\"\"Load the Stardist model and return it\"\"\"\n",
    "    model_s = StarDist2D.from_pretrained(\"2D_versatile_he\")\n",
    "    return model_s\n",
    "\n",
    "\n",
    "def run_cellpose(image, model_cellpose, diameter=None):\n",
    "    \"\"\"Run the cellpose model on the image and return the mask\"\"\"\n",
    "    channel = [[0, 0]]\n",
    "    mask_cellpose, _, _, _ = model_cellpose.eval(\n",
    "        image, batch_size=1, diameter=diameter, channels=channel\n",
    "    )\n",
    "    return mask_cellpose\n",
    "\n",
    "\n",
    "def run_stardist(image, model_stardist, nms_thresh=0.4, prob_thresh=0.5):\n",
    "    \"\"\"Run the stardist model on the image and return the mask\"\"\"\n",
    "    img_norm = image / 255\n",
    "    img_norm = normalize(img_norm, 1, 99.8)\n",
    "    mask_stardist, _ = model_stardist.predict_instances(\n",
    "        img_norm, nms_thresh=nms_thresh, prob_thresh=prob_thresh\n",
    "    )\n",
    "    return mask_stardist\n",
    "\n",
    "model_cellpose = load_cellpose()\n",
    "model_stardist = load_stardist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load an image, run CellPose to detect muscle fibers and Stardist to detect nuclei.\n",
    "try:\n",
    "    from imageio.v2 import imread\n",
    "except:\n",
    "    from imageio import imread\n",
    "\n",
    "img = imread(\"im\") # mon image \n",
    "\n",
    "# CellPose\n",
    "mask_cellpose = run_cellpose(\n",
    "    img, model_cellpose)\n",
    "mask_cellpose = mask_cellpose.astype(np.uint16)\n",
    "cellpose_mask_filename = \"results/sample_he_cellpose_mask.tiff\"\n",
    "Image.fromarray(mask_cellpose).save(cellpose_mask_filename)\n",
    "\n",
    "# Stardist\n",
    "mask_stardist = run_stardist(\n",
    "    img, model_stardist)\n",
    "mask_stardist = mask_stardist.astype(np.uint16)\n",
    "stardist_filename = \"results/sample_he_stardist_mask.tiff\"\n",
    "Image.fromarray(mask_stardist).save(stardist_filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(16,9))\n",
    "ax1.imshow(img)\n",
    "ax2.imshow(mask_cellpose)\n",
    "ax3.imshow(mask_stardist)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Based on the Cellpose Image and Stardist image we will extract the coordinates of the nuclei and muscle fibers as a table. \n",
    "# We will also extract their area in pixels, perimeter, eccentrictiy....\n",
    "from skimage.measure import regionprops_table\n",
    "import pandas as pd\n",
    "props_cellpose = regionprops_table(\n",
    "    mask_cellpose,\n",
    "    properties=[\n",
    "        \"label\",\n",
    "        \"area\",\n",
    "        \"centroid\",\n",
    "        \"eccentricity\",\n",
    "        \"bbox\",\n",
    "        \"image\",\n",
    "        \"perimeter\",\n",
    "        \"feret_diameter_max\"#ajout du diamètre\n",
    "    ],\n",
    ")\n",
    "df_cellpose = pd.DataFrame(props_cellpose)\n",
    "df_cellpose"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_cellpose.to_csv(r'data_mon im_jpg.csv', index=False, header=True) # je transforme en csv "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "#on importe les fichiers csv nécessaire \n",
    "df=pd.read_csv('muscle_atlas_clean.csv') #atlas du muscle\n",
    "df_cell=pd.read_csv('data_mon im_jpg.csv') # fichier info image 5 (taille, diamètre, centre...)\n",
    "\n",
    "\n",
    "\n",
    "def conversion_pix_µm(im, data_frame,muscle_atlas):\n",
    "    'Convertion du diamètre en µm'\n",
    "    barre_echelle= muscle_atlas.loc[(df['Number']== im), 'Calibration (um/px)']\n",
    "    \n",
    "    data_frame['diameter_µm']=(data_frame['feret_diameter_max'])*barre_echelle.values\n",
    "\n",
    "conversion_pix_µm('mon_im.jpg',df_cell,df )\n",
    "\n",
    "def count_atrophic_cells (data_frame,min_size, max_size):\n",
    "    hyper='Hypertrophy'\n",
    "    hypo= 'Hypotrophy'\n",
    "    norm= 'Normal'\n",
    "    data_frame[\"State_cell\"] = ''\n",
    "    for index in data_frame.index:\n",
    "        a=data_frame['diameter_µm'][index]\n",
    "        if a > max_size:\n",
    "            data_frame[\"State_cell\"][index]=hyper\n",
    "        elif a < min_size:\n",
    "            data_frame[\"State_cell\"][index]=hypo\n",
    "        else: \n",
    "            data_frame[\"State_cell\"][index]= norm\n",
    "\n",
    "\n",
    "count_atrophic_cells (df_cell, 30, 80)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pourcentage_state_cell (im,data_frame,muscle_atlas):\n",
    "     data = {'Number':[],'Hypertrophy': [],'Normal':[],'Hypotrophy': []}  # Ici on créer un dataframe pour mettre ensuite les valeurs des pourcentages\n",
    "     df_state_cell = pd.DataFrame(data)  \n",
    "     percentage= (data_frame['State_cell'].value_counts()/data_frame['State_cell'].count())*100\n",
    "     df_state_cell.loc[len(df_state_cell.index)] = percentage\n",
    "\n",
    "     \n",
    "     muscle_atlas.loc[(muscle_atlas['Number']== im),\"Hypertrophic_cell_%\"]=df_state_cell['Hypertrophy'].values\n",
    "     muscle_atlas.loc[(muscle_atlas['Number']== im),\"Normal_cell_%\"]=df_state_cell['Normal'].values\n",
    "     muscle_atlas.loc[(muscle_atlas['Number']== im),\"Hypotrophic_cell_%\"]=df_state_cell['Hypotrophy'].values\n",
    "\n",
    "\n",
    "pourcentage_state_cell ('mon_im.jpg',df_cell,df) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def diameter_mean_std (im,data_frame,muscle_atlas):\n",
    "    cell_mean=data_frame['diameter_µm'].mean()\n",
    "    cell_std=data_frame['diameter_µm'].std()\n",
    "    muscle_atlas.loc[(muscle_atlas['Number']== im),\"diameter_mean\"]=cell_mean\n",
    "    muscle_atlas.loc[(muscle_atlas['Number']== im),\"diameter_std\"]=cell_std\n",
    "\n",
    "\n",
    "diameter_mean_std('mon_im.jpg',df_cell,df)   \n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.13 ('stage-afaf')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "d0f278cb1c0d1780c7b3f81b6d83f04ff3238e002e40dd73cadd16a5dde7e268"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}