3c_load_test_data.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save testing images in one folder named `test_images`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.colors\n",
    "import os\n",
    "import skimage.draw\n",
    "import numpy as np\n",
    "from tqdm import tqdm\n",
    "import cv2\n",
    "from glob import glob\n",
    "import warnings\n",
    "import random\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "# Helpers\n",
    "\n",
    "def create_directory(directory):\n",
    "    '''\n",
    "    Creates a new folder in the specified directory if the folder doesn't exist.\n",
    "    INPUT\n",
    "        directory: Folder to be created, called as \"folder/\".\n",
    "    OUTPUT\n",
    "        New folder in the current directory.\n",
    "    '''\n",
    "    if not os.path.exists(directory):\n",
    "        os.makedirs(directory)\n",
    "        \n",
    "        \n",
    "        \n",
    "def read_nuclei(path):\n",
    "    \"Read raw data\"\n",
    "\n",
    "    # Load 4-channel image\n",
    "    if len(path) == 0:\n",
    "        return None\n",
    "    \n",
    "    img = skimage.io.imread(path)\n",
    "    \n",
    "    # input image\n",
    "    if len(img.shape) > 2:\n",
    "        img = img[:,:,:3]\n",
    "    # mask\n",
    "    else:\n",
    "        # do nothing\n",
    "        pass\n",
    "        \n",
    "    return img\n",
    "\n",
    "\n",
    "\n",
    "def save_nuclei(path, img):\n",
    "    \"save image\"\n",
    "    skimage.io.imsave(path, img)\n",
    "    \n",
    "    \n",
    "    \n",
    "label_map = {'Epithelial':1,\n",
    "             'Lymphocyte':2,\n",
    "             'Macrophage':4,\n",
    "             'Neutrophil':3,\n",
    "            }\n",
    "\n",
    "\n",
    "# Root directory of the project\n",
    "ROOT_DIR = os.path.abspath(\"./\")\n",
    "print(ROOT_DIR)\n",
    "# Training file directory\n",
    "IMAGES_FOLDER = os.path.join(ROOT_DIR, \"dataset\", \"Testing images/\")\n",
    "print(IMAGES_FOLDER)\n",
    "IMAGES_SUB_FOLDER = [os.path.join(IMAGES_FOLDER, i) for i in sorted(next(os.walk(IMAGES_FOLDER))[1])]\n",
    "print(IMAGES_SUB_FOLDER[:5])\n",
    "IMAGES_DEST =  os.path.join(ROOT_DIR, \"dataset\", \"test_images\")\n",
    "print(IMAGES_DEST)\n",
    "# Create folders\n",
    "create_directory(IMAGES_DEST)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# STORE IMAGES in test folder together\n",
    "\n",
    "raw_ct = 0\n",
    "for ct in tqdm(range(len(IMAGES_SUB_FOLDER[:]))):\n",
    "    \n",
    "    #print(ct)\n",
    "    \n",
    "    # Read all raw images in image sub folder\n",
    "    all_imgs = sorted(glob(IMAGES_SUB_FOLDER[ct] + '/*.tif'))\n",
    "    \n",
    "    paths = [s.split('.')[0][-25:] for s in all_imgs]\n",
    "    \n",
    "    \n",
    "    # Iterate over the individual raw images\n",
    "    for i in range(len(all_imgs)):\n",
    "        \n",
    "        # Read test image\n",
    "        #print(all_imgs[i])\n",
    "        img = read_nuclei(all_imgs[i])\n",
    "\n",
    "        # Save it\n",
    "        save_nuclei(IMAGES_DEST+ \"/{}.png\".format(paths[i]), img)\n",
    "        raw_ct+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "image_fns = sorted(next(os.walk(IMAGES_DEST))[2])\n",
    "image_fns[:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get data stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "w = []\n",
    "h = []\n",
    "\n",
    "for i in range(len(IMAGES_DEST)):\n",
    "    image = skimage.io.imread(os.path.join(IMAGES_DEST, image_fns[i]))\n",
    "    w.append(image.shape[1])\n",
    "    h.append(image.shape[0])\n",
    "    \n",
    "w = np.array(w)\n",
    "h = np.array(h)\n",
    "\n",
    "print(w.shape, h.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Mean of hieght\n",
    "np.mean(h), np.std(h)\n",
    "#(607.6363636363636, 534.3626403529337)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Mean of hieght\n",
    "np.mean(w), np.std(w)\n",
    "#(569.4727272727273, 401.6142814621763)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.max(h), np.min(h)\n",
    "#(2500, 82)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.max(w), np.min(w)\n",
    "#(1987, 35)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def process(image, mask):\n",
    "    f, axarr = plt.subplots(1,2, figsize=(16, 16))\n",
    "    axarr[0].imshow(image)\n",
    "    axarr[1].imshow(mask, cmap='gray')\n",
    "\n",
    "\n",
    "def sliding_window(image, step, window):\n",
    "    x_loc = []\n",
    "    y_loc = []\n",
    "    cells = []\n",
    "    \n",
    "    for y in range(0, image.shape[0], step):\n",
    "        for x in range(0, image.shape[1], step):\n",
    "            cells.append(image[y:y + window[1], x:x + window[0]])\n",
    "            x_loc.append(x)\n",
    "            y_loc.append(y)\n",
    "    return x_loc, y_loc, cells\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Process images with sliding window"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "image_fns = sorted(next(os.walk(IMAGES_DEST))[2])\n",
    "\n",
    "image = skimage.io.imread(os.path.join(IMAGES_DEST, image_fns[random.randrange(len(image_fns))]))\n",
    "\n",
    "# Get locations\n",
    "x_pos, y_pos, cells = sliding_window(image, 8, (64, 64))\n",
    "\n",
    "# Array for storing predictions\n",
    "pred = np.zeros((image.shape[0], image.shape[1]))\n",
    "\n",
    "for (x, y, cell) in tqdm(zip(x_pos, y_pos, cells)):\n",
    "    \n",
    "    # Get patch\n",
    "    patch = image[y:y + 64, x:x + 64]\n",
    "    \n",
    "    # Get size\n",
    "    raw_dim = (patch.shape[1], patch.shape[0]) # W, H\n",
    "    #print(raw_dim)\n",
    "    #print(patch.shape)\n",
    "    \n",
    "    \n",
    "    if raw_dim != (64, 64):\n",
    "        \n",
    "        \n",
    "        # Resize to 64x64\n",
    "        patch = cv2.resize(patch, (64, 64), interpolation = cv2.INTER_AREA)\n",
    "        \n",
    "        \n",
    "        # Do stuffffff\n",
    "        processed = cv2.cvtColor(patch, cv2.COLOR_BGR2GRAY)\n",
    "        \n",
    "        \n",
    "        # Resize back to original shape\n",
    "        processed = cv2.resize(processed, raw_dim, interpolation = cv2.INTER_AREA)\n",
    "    \n",
    "    else:\n",
    "        \n",
    "        # Do stuffffff\n",
    "        processed = cv2.cvtColor(patch, cv2.COLOR_BGR2GRAY)\n",
    "    \n",
    "    \n",
    "    # Add in dummy image\n",
    "    pred[y:y + 64, x:x + 64] = processed    \n",
    "\n",
    "print(image.shape, pred.shape)\n",
    "process(image, pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}