Expand_data_from_segmentation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#import packages\n",
    "\n",
    "import numpy as np\n",
    "import napari\n",
    "from skimage.measure import regionprops\n",
    "from scipy.ndimage import zoom\n",
    "import operator\n",
    "from pathlib import Path\n",
    "%gui qt\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#load the images\n",
    "labs = np.load('labs.npz')['arr_0']\n",
    "mem_im = np.load('mem_im.npz')['arr_0']\n",
    "nuc_im = np.load('nuc_im.npz')['arr_0']\n",
    "\n",
    "#get the props of the labs\n",
    "props = regionprops(labs)\n",
    "\n",
    "#get the average centroid of the initial image cells\n",
    "all_z = []\n",
    "all_x = []\n",
    "all_y = []\n",
    "for prop in props:\n",
    "    all_z.append(prop['centroid'][0])\n",
    "    all_y.append(prop['centroid'][1])\n",
    "    all_x.append(prop['centroid'][2])\n",
    "average_centroid = (np.mean(all_z), np.mean(all_y), np.mean(all_x))\n",
    "\n",
    "#make the original image prop dict\n",
    "propDict = {}\n",
    "propDict['original_im'] = {}\n",
    "for prop in props:\n",
    "    propDict['original_im'][prop['label']] = {}\n",
    "    propDict['original_im'][prop['label']]['centroid'] = prop['centroid']\n",
    "    propDict['original_im'][prop['label']]['coords'] = prop['coords']\n",
    "\n",
    "#make a new output folder\n",
    "Path('output').mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "#define a new (bigger) image shape\n",
    "new_shape = (labs.shape[0] + 200, labs.shape[1] + 200, labs.shape[2] + 200)\n",
    "\n",
    "#make a new nuclei and membrane image to hold the expanded sequence\n",
    "whole_im = np.zeros((30, new_shape[0], new_shape[1], new_shape[2]), dtype=np.uint16)\n",
    "whole_nuc = np.zeros((30, new_shape[0], new_shape[1], new_shape[2]), dtype=np.uint16)\n",
    "\n",
    "#define a series of zooms to iterate through\n",
    "scaling = np.arange(1.05, 2.55, 0.050)\n",
    "\n",
    "for num, scale in enumerate(scaling):\n",
    "    #make new images for the scaled membrane and nuclei\n",
    "    new_image = np.zeros(new_shape, dtype=np.uint16)\n",
    "    new_image_nuc = np.zeros(new_shape, dtype=np.uint16)\n",
    "    \n",
    "    #zoom by the appropriate scale\n",
    "    zoomed_array = zoom(labs, (scale, scale, scale), order=0)\n",
    "    zoomed_props = regionprops(zoomed_array)\n",
    "\n",
    "    #add the new (zoomed) centroids to the dict\n",
    "    propDict['zoomed_im'] = {}\n",
    "    for prop in zoomed_props:\n",
    "        propDict['zoomed_im'][prop['label']] = {}\n",
    "        propDict['zoomed_im'][prop['label']]['centroid'] = prop['centroid']\n",
    "\n",
    "        \n",
    "    #from these, calculate the average centroid position of all the centroids\n",
    "    all_z = []\n",
    "    all_x = []\n",
    "    all_y = []\n",
    "\n",
    "    for cell in propDict['zoomed_im'].keys():\n",
    "        all_z.append(propDict['zoomed_im'][cell]['centroid'][0])\n",
    "        all_y.append(propDict['zoomed_im'][cell]['centroid'][1])\n",
    "        all_x.append(propDict['zoomed_im'][cell]['centroid'][2])\n",
    "    zoomed_average_centroid = (np.mean(all_z), np.mean(all_y), np.mean(all_x))    \n",
    "\n",
    "    #loop through the cells\n",
    "    for cell in propDict['original_im'].keys():\n",
    "        \n",
    "        #calculate the delta in the centroid position\n",
    "        image_center = (new_image.shape[0]/2, new_image.shape[1]/2, new_image.shape[2]/2)\n",
    "        original_centroid = propDict['original_im'][cell]['centroid']\n",
    "        zoomed_centroid = propDict['zoomed_im'][cell]['centroid']\n",
    "        \n",
    "        delta = tuple(map(operator.sub, zoomed_centroid, original_centroid))\n",
    "\n",
    "        #calculate the difference from the average centroid\n",
    "        centroid_delta = tuple(map(operator.sub, zoomed_average_centroid, image_center))\n",
    "\n",
    "        #get, and make a copy of the coordinates for this cell\n",
    "        coords = propDict['original_im'][cell]['coords']\n",
    "        coords_copy = np.copy(coords)\n",
    "\n",
    "        #apply the shift in centroid position to each coordinate\n",
    "        for i, index in enumerate(coords_copy):        \n",
    "                index[0] = index[0] + delta[0] - centroid_delta[0]\n",
    "                index[1] = index[1] + delta[1] - centroid_delta[1]\n",
    "                index[2] = index[2] + delta[2] - centroid_delta[2]\n",
    "                try:\n",
    "                    new_image[index[0], index[1], index[2]] = mem_im[coords[i][0], coords[i][1], coords[i][2]]\n",
    "                    new_image_nuc[index[0], index[1], index[2]] = nuc_im[coords[i][0], coords[i][1], coords[i][2]]\n",
    "                except IndexError:\n",
    "                    continue\n",
    "    #save the files\n",
    "    \n",
    "    #add this image to the stack of expanded images\n",
    "    whole_im[num,:,:,:] = new_image\n",
    "    nuc_im[num,:,:,:] = new_image_nuc\n",
    "    \n",
    "\n",
    "    \n",
    "#look at the image\n",
    "\n",
    "viewer = napari.Viewer()   \n",
    "viewer.add_image(whole_im, colormap = 'green', blending = 'additive')\n",
    "viewer.add_image(nuc_im, colormap = 'magenta', blending = 'additive')\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}