notebooks/part_1_segmentation_workflows/1.5_infer_peroxisome.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Infer ***peroxisome*** - part 5️⃣\n",
    "\n",
    "--------------\n",
    "## **OBJECTIVE**\n",
    "### <input type=\"checkbox\"/> Infer sub-cellular component  ***peroxisomes***  \n",
    "Segment the ***peroxisomes*** from a single channel (membrane marker). This workflow was optimized for images of fluorescently tagged SKL, a membrane targeting sequence."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---------------------\n",
    "## infer ***peroxisomes***\n",
    "### summary of steps \n",
    "\n",
    "➡️ **EXTRACTION**\n",
    "- **`STEP 1`** - Select a channel for segmentation\n",
    "\n",
    "    - select single channel containing the peroxisomes marker (channel number = user input)\n",
    "\n",
    "**PRE-PROCESSING**\n",
    "- **`STEP 2`** - Rescale and smooth image\n",
    "\n",
    "  - rescale intensity of composite image (min=0, max=1)\n",
    "  - median filter (median size = user input)\n",
    "  - gaussian filter (sigma = user input)\n",
    "\n",
    "**CORE PROCESSING**\n",
    "- **`STEP 3`** - ‘Dot’ thresholding method (AICSSeg)\n",
    "\n",
    "  - apply \"dot\" thresholding method (for small round objects) from the Allen Cell [aicssegmentation](https://github.com/AllenCell/aics-segmentation) package (size scale, threshold cutoff and method = user input)\n",
    "\n",
    "**POST-PROCESSING**\n",
    "- **`STEP 4`** - Remove small holes and objects\n",
    "\n",
    "  - fill holes (hole size = user input)\n",
    "  - remove small objects (object size = user input)\n",
    "  - filter method (method = user input)\n",
    "\n",
    "**POST-POST-PROCESSING**\n",
    "- **`STEP 5`** - Label objects\n",
    "\n",
    "    - label unique peroxisome objects based on connectivity\n",
    "\n",
    "**EXPORT** ➡️\n",
    "- save labeled ***peroxisomes*** (perox, PR) as unsigned integer 16-bit tif files\n",
    "\n",
    "\n",
    "\n",
    "> ###### **Generally following the Allen Cell Segmenter procedure for segmentation of perixisomes from the [playground_dots.ipynb](https://github.com/AllenInstitute/aics-segmentation/blob/master/lookup_table_demo/playground_dots.ipynb) notebook**"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---------------------\n",
    "## **IMPORTS**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### &#x1F3C3; **Run code; no user input required**\n",
    "\n",
    "&#x1F453; **FYI:** This code block loads all of the necessary python packages and functions you will need for this notebook. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "import os\n",
    "\n",
    "import numpy as np\n",
    "import napari\n",
    "from napari.utils.notebook_display import nbscreenshot\n",
    "\n",
    "from infer_subc.core.file_io import (read_czi_image,\n",
    "                                     export_inferred_organelle,\n",
    "                                     list_image_files)\n",
    "\n",
    "from infer_subc.core.img import *                                     \n",
    "\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **LOAD AND READ IN IMAGE FOR PROCESSING**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### &#x1F6D1; &#x270D; **User Input Required:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Specify the file type of your raw data that will be analyzed. Ex) \".czi\" or \".tiff\"\n",
    "im_type = \".czi\"\n",
    "\n",
    "## Define the path to the directory that contains the input image folder.\n",
    "data_root_path = Path(os.path.expanduser(\"~\")) / \"Documents/Python_Scripts/Infer-subc\"\n",
    "\n",
    "## Specify which subfolder that contains the input data\n",
    "in_data_path = data_root_path / \"raw\"\n",
    "\n",
    "## Specify the output folder\n",
    "out_data_path = data_root_path / \"out\"\n",
    "\n",
    "# Specify which file you'd like to segment from the img_file_list\n",
    "test_img_n = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### &#x1F3C3; **Run code; no user input required**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not Path.exists(out_data_path):\n",
    "    Path.mkdir(out_data_path)\n",
    "    print(f\"making {out_data_path}\")\n",
    "\n",
    "img_file_list = list_image_files(in_data_path,im_type)\n",
    "# pd.set_option('display.max_colwidth', None)\n",
    "# pd.DataFrame({\"Image Name\":img_file_list})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_img_name = img_file_list[test_img_n]\n",
    "\n",
    "img_data,meta_dict = read_czi_image(test_img_name)\n",
    "\n",
    "channel_names = meta_dict['name']\n",
    "img = meta_dict['metadata']['aicsimage']\n",
    "scale = meta_dict['scale']\n",
    "channel_axis = meta_dict['channel_axis']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ***EXTRACTION prototype - perox***"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **`STEP 1` - Select a channel for segmentation**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- select single channel containing the peroxisomes marker (channel number = user input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "###################\n",
    "# INPUT\n",
    "###################\n",
    "PEROX_CH = 4\n",
    "raw_perox = select_channel_from_raw(img_data, PEROX_CH)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ***PRE-PROCESSING prototype - perox***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **`STEP 2` - Rescale and smooth image**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- rescale intensity of composite image (min=0, max=1)\n",
    "- median filter (median size = user input)\n",
    "- gaussian filter (sigma = user input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "###################\n",
    "# PRE_PROCESSING\n",
    "###################\n",
    "median_sz = 0\n",
    "gauss_sig = 1.34\n",
    "\n",
    "struct_img =  scale_and_smooth(raw_perox,\n",
    "                               median_size = median_sz,\n",
    "                               gauss_sigma = gauss_sig)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ***CORE-PROCESSING prototype - perox***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **`STEP 3` -  ‘Dot’ thresholding method (AICSSeg)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- apply \"dot\" thresholding method (for small round objects) from the Allen Cell [aicssegmentation](https://github.com/AllenCell/aics-segmentation) package (size scale, threshold cutoff and method = user input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "###################\n",
    "# CORE_PROCESSING\n",
    "###################\n",
    "# segment small round structures with this\n",
    "dot_scale_1 = 1\n",
    "dot_cut_1 = 0.06\n",
    "\n",
    "dot_scale_2 = 0\n",
    "dot_cut_2 = 0\n",
    "\n",
    "dot_scale_3 = 0\n",
    "dot_cut_3 = 0\n",
    "\n",
    "dot_method = \"3D\"\n",
    "\n",
    "bw_extra = dot_filter_3(struct_img,\n",
    "                        dot_scale_1,\n",
    "                        dot_cut_1,\n",
    "                        dot_scale_2,\n",
    "                        dot_cut_2,\n",
    "                        dot_scale_3,\n",
    "                        dot_cut_3,\n",
    "                        dot_method)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ***POST-PROCESSING prototype - perox***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **`STEP 4` - Remove small holes and objects**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- fill holes (hole size = user input)\n",
    "- remove small objects (object size = user input)\n",
    "- filter method (method = user input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "###################\n",
    "# POST_PROCESSING\n",
    "###################\n",
    "hole_min_width = 0\n",
    "hole_max_width = 0\n",
    "\n",
    "small_object_width = 2\n",
    "\n",
    "fill_filter_method = \"3D\"\n",
    "\n",
    "cleaned_img2 = fill_and_filter_linear_size(bw_extra, \n",
    "                                           hole_min=hole_min_width, \n",
    "                                           hole_max=hole_max_width, \n",
    "                                           min_size=small_object_width,\n",
    "                                           method=fill_filter_method)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ***POST-POST-PROCESSING prototype - perox***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **`STEP 5` - Label objects**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- label unique peroxisome objects based on connectivity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "###################\n",
    "# LABELING\n",
    "###################\n",
    "peroxisomes_labels = label_uint16(cleaned_img2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "peroxisomes_labels.dtype"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Visualize with `napari` 1**\n",
    "Visualize the first-pass segmentation and labeling with `napari`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "viewer = napari.Viewer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "viewer.add_image(\n",
    "    struct_img)\n",
    "\n",
    "viewer.add_image(\n",
    "    cleaned_img2,\n",
    "    opacity=0.3)\n",
    "\n",
    "viewer.add_image(\n",
    "    peroxisomes_labels,\n",
    "    opacity=0.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ***EXTRACTION prototype - perox***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- save labeled ***peroxisomes*** (perox, PR) as unsigned integer 16-bit tif files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "out_file_n = export_inferred_organelle(peroxisomes_labels, \"perox\", meta_dict, out_data_path)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **Define `_infer_perox` function**\n",
    "\n",
    "> ###### 📝 **these functions mainly serve for downstream prototyping in the notebooks. Each step above has an independent function that is implemented in the plugin for easy of use**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##########################\n",
    "#  infer_perox\n",
    "##########################\n",
    "def _infer_perox( \n",
    "        in_img: np.ndarray,\n",
    "        peroxi_ch: int,\n",
    "        median_sz: int,\n",
    "        gauss_sig: float,\n",
    "        dot_scale_1: float,\n",
    "        dot_cut_1: float,\n",
    "        dot_scale_2: float,\n",
    "        dot_cut_2: float,\n",
    "        dot_scale_3: float,\n",
    "        dot_cut_3: float,\n",
    "        dot_method: str,\n",
    "        hole_min_width: int,\n",
    "        hole_max_width: int,\n",
    "        small_object_width: int,\n",
    "        fill_filter_method: str\n",
    "        ) -> np.ndarray:\n",
    "    \"\"\"\n",
    "    Procedure to infer peroxisome from linearly unmixed input.\n",
    "\n",
    "   Parameters\n",
    "    ------------\n",
    "    in_img: \n",
    "        a 3d image containing all the channels\n",
    "    median_sz: \n",
    "        width of median filter for signal\n",
    "    gauss_sig: \n",
    "        sigma for gaussian smoothing of  signal\n",
    "    dot_scale: \n",
    "        scales (log_sigma) for dot filter (1,2, and 3)\n",
    "    dot_cut: \n",
    "        threshold for dot filter thresholds (1,2,and 3)\n",
    "    small_obj_w: \n",
    "        minimu object size cutoff for nuclei post-processing\n",
    " \n",
    "    Returns\n",
    "    -------------\n",
    "    peroxi_object\n",
    "        mask defined extent of peroxisome object\n",
    "    \"\"\"\n",
    "\n",
    "    ###################\n",
    "    # EXTRACT\n",
    "    ###################    \n",
    "    peroxi = select_channel_from_raw(in_img, peroxi_ch)\n",
    "\n",
    "    ###################\n",
    "    # PRE_PROCESSING\n",
    "    ###################    \n",
    "    peroxi =  scale_and_smooth(peroxi,\n",
    "                               median_size = median_sz,\n",
    "                               gauss_sigma = gauss_sig)\n",
    "\n",
    "   ###################\n",
    "    # CORE_PROCESSING\n",
    "    ###################\n",
    "    bw = dot_filter_3(peroxi, dot_scale_1, dot_cut_1, dot_scale_2, dot_cut_2, dot_scale_3, dot_cut_3, dot_method)\n",
    "\n",
    "    ###################\n",
    "    # POST_PROCESSING\n",
    "    ###################\n",
    "    struct_obj = fill_and_filter_linear_size(bw, \n",
    "                                             hole_min=hole_min_width, \n",
    "                                             hole_max=hole_max_width, \n",
    "                                             min_size=small_object_width,\n",
    "                                             method=fill_filter_method)\n",
    "\n",
    "    ###################\n",
    "    # LABELING\n",
    "    ###################\n",
    "    struct_obj1 = label_uint16(struct_obj)\n",
    "\n",
    "    return struct_obj1\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **Test  `_infer_perox` function**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "_perox_object =  _infer_perox(\n",
    "        img_data,\n",
    "        PEROX_CH,\n",
    "        median_sz,\n",
    "        gauss_sig,\n",
    "        dot_scale_1,\n",
    "        dot_cut_1,\n",
    "        dot_scale_2,\n",
    "        dot_cut_2, \n",
    "        dot_scale_3,\n",
    "        dot_cut_3,\n",
    "        dot_method,\n",
    "        hole_min_width,\n",
    "        hole_max_width,\n",
    "        small_object_width,\n",
    "        fill_filter_method) \n",
    "\n",
    "_perox_object.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.all(peroxisomes_labels == _perox_object)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Visualize with `napari` 2**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "viewer.add_image(\n",
    "    _perox_object,\n",
    "    opacity=0.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nbscreenshot(viewer, canvas_only=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "viewer.close()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------------\n",
    "### NEXT: INFER ENDOPLASMIC RETICULUM\n",
    "\n",
    "proceed to [1.6_infer_ER.ipynb](./1.6_infer_ER.ipynb)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "infer-subc",
   "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.10.11"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}