1_data_process_MoNuSAC.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Make two folders: images, masks\n",
    "\n",
    "```\n",
    "data_processedv0/\n",
    "                images/\n",
    "                masks/\n",
    "```"
   ]
  },
  {
   "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\", \"MoNuSAC_images_and_annotations/\")\n",
    "MASKS_FOLDER = os.path.join(ROOT_DIR, \"dataset\", \"MoNuSAC_masks/\")\n",
    "print(IMAGES_FOLDER, MASKS_FOLDER)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "IMAGES_DEST =  os.path.join(ROOT_DIR, \"dataset\", \"data_processedv0\", \"images/\")\n",
    "MASKS_DEST = os.path.join(ROOT_DIR, \"dataset\", \"data_processedv0\", \"masks/\")\n",
    "\n",
    "print(IMAGES_DEST)\n",
    "print(MASKS_DEST)\n",
    "\n",
    "# Create folders\n",
    "create_directory(IMAGES_DEST)\n",
    "create_directory(MASKS_DEST)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "IMAGES_SUB_FOLDER = [os.path.join(IMAGES_FOLDER, i) for i in sorted(next(os.walk(IMAGES_FOLDER))[1])]\n",
    "IMAGES_SUB_FOLDER[:5]\n",
    "\n",
    "#IMAGES_SUB_FOLDER = sorted([os.path.join(IMAGES_FOLDER, i) for i in os.walk(IMAGES_FOLDER)])\n",
    "#IMAGES_SUB_FOLDER[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MASKS_SUB_FOLDER = [os.path.join(MASKS_FOLDER, i) for i in sorted(next(os.walk(MASKS_FOLDER))[1])]\n",
    "MASKS_SUB_FOLDER[:5]\n",
    "\n",
    "#MASKS_SUB_FOLDER = sorted([os.path.join(MASKS_FOLDER, i) for i in os.listdir(MASKS_FOLDER)])\n",
    "#MASKS_SUB_FOLDER[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = sorted(next(os.walk(IMAGES_FOLDER))[1])\n",
    "b = sorted(next(os.walk(MASKS_FOLDER))[1])\n",
    "print(a[:2], b[:2])\n",
    "\n",
    "for x,y in zip(a,b):\n",
    "    if x == y:\n",
    "        print(True)\n",
    "    else:\n",
    "        print(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ct = 10\n",
    "print(IMAGES_SUB_FOLDER[ct])\n",
    "print(MASKS_SUB_FOLDER[ct])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Process raw data to initial version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### MAIN#########\n",
    "\n",
    "images = []\n",
    "masks = []\n",
    "\n",
    "iterator = 0\n",
    "\n",
    "raw_ct = 0\n",
    "gt_ct = 0\n",
    "for ct in tqdm(range(len(IMAGES_SUB_FOLDER[:]))):\n",
    "    #print(ct)\n",
    "    \n",
    "    #print(IMAGES_SUB_FOLDER[ct], MASKS_SUB_FOLDER[ct])\n",
    "\n",
    "    # Read all raw images in image sub folder\n",
    "    all_imgs = sorted(glob(IMAGES_SUB_FOLDER[ct] + '/*.tif'))\n",
    "\n",
    "    # Read the mask sub folders\n",
    "    all_mask_sub_dir = sorted(glob(MASKS_SUB_FOLDER[ct]+ '/*'))\n",
    "\n",
    "    # Iterate over the individual raw images\n",
    "    for i in range(len(all_imgs)):\n",
    "\n",
    "        #print(i)\n",
    "        img = read_nuclei(all_imgs[i])\n",
    "\n",
    "        # Save it\n",
    "        # .............\n",
    "        \n",
    "        save_nuclei(IMAGES_DEST+ \"{}.png\".format(raw_ct), img)\n",
    "        raw_ct+=1\n",
    "        \n",
    "        #print(IMAGES_DEST+ \"{}_{}.png\".format(ct, i))\n",
    "        \n",
    "        # Add to list\n",
    "        #images.append(img)\n",
    "\n",
    "    # Iterate over the individual mask sub folders\n",
    "    for j in range(len(all_mask_sub_dir)):\n",
    "\n",
    "        # Go to each sub folder\n",
    "        # Read the 4 class folders\n",
    "        class_sub_dir = sorted(glob(all_mask_sub_dir[j]+ '/*'))  \n",
    "\n",
    "        # Make list for masks from each class fodlers\n",
    "        final_masks = []\n",
    "\n",
    "        # For each class folder get the mask\n",
    "        for i in range(len(class_sub_dir)):\n",
    "\n",
    "            # get the mask in the subfolder\n",
    "            mask_paths = sorted(glob(class_sub_dir[i] + '/*.tif'))\n",
    "\n",
    "            # If more than one mask present in folder(maybe not)\n",
    "            # For each class folder: 1) read the mask 2) Convert to class label from the binary class label\n",
    "            for j in range(len(mask_paths)):\n",
    "\n",
    "                if i == 0:\n",
    "                    epithelial_mask = read_nuclei(mask_paths[j])\n",
    "                    epithelial_mask = np.where(epithelial_mask==255.0, 1.0, epithelial_mask)\n",
    "                    final_masks.append(epithelial_mask)\n",
    "\n",
    "                if i == 1:\n",
    "                    lymphocyte_mask = read_nuclei(mask_paths[j])\n",
    "                    lymphocyte_mask = np.where(lymphocyte_mask==255.0, 2.0, lymphocyte_mask)\n",
    "                    final_masks.append(lymphocyte_mask)\n",
    "                if i == 2:\n",
    "                    macrophage_mask = read_nuclei(mask_paths[j])\n",
    "                    macrophage_mask = np.where(macrophage_mask==255.0, 4.0, macrophage_mask)\n",
    "                    final_masks.append(macrophage_mask)\n",
    "                if i == 3:\n",
    "                    neutrophil_mask = read_nuclei(mask_paths[j])\n",
    "                    neutrophil_mask = np.where(neutrophil_mask==255.0, 3.0, neutrophil_mask)\n",
    "                    final_masks.append(neutrophil_mask)\n",
    "\n",
    "                    \n",
    "        # Overlay masks\n",
    "        \n",
    "        if len(final_masks) == 1:\n",
    "            \n",
    "            # If only one mask, read it directly\n",
    "            mask = final_masks[0]\n",
    "            \n",
    "        else:\n",
    "            \n",
    "            # For multiple masks, read maximum along the axis\n",
    "            #mask = np.maximum.reduce(*final_masks, dtype=np.float64)\n",
    "            mask = np.amax(final_masks, axis=0)\n",
    "            \n",
    "\n",
    "        # Save it\n",
    "        # .............\n",
    "\n",
    "        mask = mask.astype(np.uint8)\n",
    "        #print(mask.shape, ct, i, iterator)\n",
    "        save_nuclei(MASKS_DEST + \"{}.png\".format(gt_ct), mask)\n",
    "        gt_ct+=1\n",
    "        \n",
    "        iterator+=1\n",
    "\n",
    "        # Add to list\n",
    "        #masks.append(mask)\n",
    "                \n",
    "    \n",
    "print(len(images), len(masks))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sanity check"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load a random image and mask\n",
    "image_fns = sorted(next(os.walk(IMAGES_DEST))[2])\n",
    "gt_fns = sorted(next(os.walk(MASKS_DEST))[2])\n",
    "\n",
    "# Random index\n",
    "idx = 94 #random.randrange(len(image_fns))\n",
    "print(\"Index: \", idx)\n",
    "print(image_fns[idx])\n",
    "# Read image and mask\n",
    "image = skimage.io.imread(os.path.join(IMAGES_DEST, image_fns[idx]))\n",
    "gt = skimage.io.imread(os.path.join(MASKS_DEST, gt_fns[idx]))\n",
    "\n",
    "# Test!\n",
    "assert image.shape[:2] == gt.shape, \"Wrong image or ground truth!\"\n",
    "assert image.dtype == gt.dtype, \"Wrong data types!\"\n",
    "print(image.shape, gt.shape)\n",
    "\n",
    "# Flatten to get unique -> different classes in the mask\n",
    "val1 = gt.flatten()\n",
    "print(\"Ground truth classes: \", np.unique(val1))\n",
    "\n",
    "\n",
    "f, axarr = plt.subplots(1,2, figsize=(16,16))\n",
    "\n",
    "norm=plt.Normalize(0,4) # 5 classes including BG\n",
    "map_name = matplotlib.colors.LinearSegmentedColormap.from_list(\"\", [\"black\", \"red\",\"yellow\",\"blue\", \"green\"])\n",
    "#map_name = 'magma'\n",
    "\n",
    "# idx = 154 all classes\n",
    "axarr[0].imshow(image, cmap=map_name, norm=norm)\n",
    "axarr[1].imshow(gt, cmap=map_name, norm=norm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# If using this block of code, run the primary for loop for two or three folder, for experimentation.\n",
    "\n",
    "#f, axarr = plt.subplots(1,2, figsize=(16,16))\n",
    "#ct = 3\n",
    "\n",
    "#assert images[ct].shape[:-1] == masks[ct].shape\n",
    "#axarr[0].imshow(images[ct])\n",
    "#axarr[1].imshow(masks[ct])\n",
    "\n",
    "#val = masks[ct].flatten()\n",
    "#print(\"Uniques: \", np.unique(val))"
   ]
  },
  {
   "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, cmap=map_name, norm=norm)\n",
    "    axarr[1].imshow(mask, cmap=map_name, norm=norm)\n",
    "    \n",
    "#for img, msk in zip(images, masks):\n",
    "#    process(img, msk)\n",
    "\n",
    "\n",
    "#label_map = {'Epithelial':1,\n",
    "#             'Lymphocyte':2,\n",
    "#             'Macrophage':4,\n",
    "#             'Neutrophil':3,\n",
    "#            }\n",
    "\n",
    "\n",
    "for i in range(10):\n",
    "    \n",
    "    idx = random.randrange(len(image_fns))\n",
    "    print(\"Index: \", idx)\n",
    "    \n",
    "    image = skimage.io.imread(os.path.join(IMAGES_DEST, image_fns[idx]))\n",
    "    gt = skimage.io.imread(os.path.join(MASKS_DEST, gt_fns[idx]))\n",
    "    print(image.shape)\n",
    "    \n",
    "    assert image.shape[:2] == gt.shape, \"Wrong image or ground truth!\"\n",
    "    assert image.dtype == gt.dtype, \"Wrong data types!\"\n",
    "\n",
    "    process(image, gt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get mean and std of image size\n",
    "\n",
    "idx = random.randrange(len(image_fns))\n",
    "print(\"Index: \", idx)\n",
    "\n",
    "image = skimage.io.imread(os.path.join(IMAGES_DEST, image_fns[idx]))\n",
    "gt = skimage.io.imread(os.path.join(MASKS_DEST, gt_fns[idx]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "w = []\n",
    "h = []\n",
    "\n",
    "image_fns = sorted(next(os.walk(IMAGES_DEST))[2])\n",
    "\n",
    "for i in range(len(image_fns)):\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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Mean of hieght\n",
    "np.mean(w), np.std(w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.max(h), np.min(h)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.max(w), np.min(w)"
   ]
  },
  {
   "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
}