1_data_process_clef19.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Construct numpy array for whole training dataset using the uniformizing techniques\n",
    "\n",
    "Had to be run three times for each technique. (Refactor!)\n",
    "\n",
    "* SSS\n",
    "* ESS\n",
    "* SIZ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "EFS1aX5vqVYO"
   },
   "outputs": [],
   "source": [
    "# Run this cell once\n",
    "#!pip install SimpleITK # for NIFTI file conversion to numpy array\n",
    "#!pip install tqdm # for seeing progress"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ATTENTION\n",
    "\n",
    "Put all NIFTI files from TrainingSet_2_of_2 to TrainingSet_1_of_2, you should get 218 NIFTI files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "DPN4li6fpbsg"
   },
   "outputs": [],
   "source": [
    "import SimpleITK as sitk\n",
    "import os\n",
    "from tqdm import tqdm\n",
    "import numpy as np \n",
    "import pandas as pd\n",
    "import os\n",
    "import scipy.ndimage\n",
    "import matplotlib.pyplot as plt\n",
    "from numpy.random import rand\n",
    "from skimage import measure, morphology\n",
    "import cv2\n",
    "from scipy.ndimage import zoom\n",
    "%matplotlib inline\n",
    "\n",
    "\n",
    "np.random.seed(1)\n",
    "\n",
    "# Helpers functions\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",
    "# Define paths\n",
    "base_path = os.path.abspath(\"./\") # Your root directory\n",
    "dataset_path = os.path.join(base_path, \"dataset\") # Your dataset folder\n",
    "model_path = os.path.join(base_path, \"models\")\n",
    "log_path = os.path.join(base_path, \"logs\")\n",
    "\n",
    "# Raw data path\n",
    "INPUT_FOLDER = 'TrainingSet_1_of_2/'  \n",
    "training_data_raw = os.path.join(dataset_path, INPUT_FOLDER)\n",
    "\n",
    "# Check inside target folder\n",
    "print(os.listdir(dataset_path))\n",
    "print(training_data_raw)\n",
    "\n",
    "patients = sorted(os.listdir(training_data_raw))\n",
    "print(patients[:10])\n",
    "\n",
    "y_train = np.load(\"{}/y_train_clef.npy\".format(dataset_path))\n",
    "print(y_train.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "xhzIJnxaqOJf"
   },
   "outputs": [],
   "source": [
    "# Resize 2D slices\n",
    "w, h = 128, 128\n",
    "def rs_img(img):\n",
    "    '''W and H is 128 now\n",
    "    '''\n",
    "    img = np.transpose(img)\n",
    "    flatten = [cv2.resize(img[:,:,i], (w, h), interpolation=cv2.INTER_CUBIC) for i in range(img.shape[-1])]\n",
    "    img = np.array(np.dstack(flatten)) \n",
    "    return img\n",
    "\n",
    "\n",
    "# Subset slice selection (SSS)\n",
    "def change_depth_sss(img):\n",
    "    \n",
    "    factor = 16\n",
    "    img_start = img[:,:,:factor]\n",
    "    \n",
    "    mid = int(img.shape[-1]/2)\n",
    "    img_middle = img[:,:,mid-factor:mid+factor]\n",
    "    \n",
    "    img_end = img[:,:,-factor:]\n",
    "    img = np.concatenate((img_start, img_middle, img_end), axis=2)\n",
    "    return img\n",
    "\n",
    "\n",
    "# Even slice selection (ESS)\n",
    "def change_depth_ess(img):\n",
    "    \n",
    "    '''ESS depth size is 32 as min depth size is 47, so we cannot evenly select 64 slices!'''\n",
    "\n",
    "    # Ignore volumes which have depth less than 64\n",
    "    target_depth = 64\n",
    "\n",
    "    #print(img.shape) \n",
    "\n",
    "    scan_depth = int(img.shape[-1])\n",
    "    \n",
    "    # If depth is not 64, make it 64\n",
    "    if scan_depth < 64:\n",
    "        number = 64 - scan_depth\n",
    "        #print(number)\n",
    "        # take last image and stack\n",
    "        extend = [img[:,:,-1] for _ in range(number)]\n",
    "        extend = np.array(np.dstack(extend))\n",
    "        #print(extend.shape)\n",
    "        img = np.concatenate((img, extend), axis=2)\n",
    "    \n",
    "    else:\n",
    "        factor = int(np.floor(scan_depth / target_depth)) # min depth is 32\n",
    "        #print(factor) # floor and ceil result in different values\n",
    "        #print(scan_depth, factor)\n",
    "\n",
    "        flatten = []\n",
    "        idx = 0\n",
    "\n",
    "        for i in range(0, scan_depth, factor):\n",
    "          #print(idx)\n",
    "\n",
    "            if idx>=scan_depth:\n",
    "                break\n",
    "            else:\n",
    "                flatten.append(img[:,:,i])\n",
    "\n",
    "        img = np.array(np.dstack(flatten))\n",
    "\n",
    "    # hardcode from bottom, if not 64 slices\n",
    "    img = img[:,:,:target_depth]     \n",
    "\n",
    "    #print(\"Final shape: \", img.shape)\n",
    "    \n",
    "    # hardcode from bottom, if not 32 slices\n",
    "    img = img[:,:,:target_depth]\n",
    "\n",
    "    assert img.shape[-1] == target_depth , \"Error\"\n",
    "    return img\n",
    "\n",
    "\n",
    "# Spline interpolated zoom (SIZ)\n",
    "def change_depth_siz(img):\n",
    "    desired_depth = 64\n",
    "    current_depth = img.shape[-1]\n",
    "    depth = current_depth / desired_depth\n",
    "    depth_factor = 1 / depth\n",
    "    img_new = zoom(img, (1, 1, depth_factor), mode='nearest')\n",
    "    return img_new\n",
    "\n",
    "\n",
    "#def normalize(image):\n",
    "    \n",
    " #   MIN_BOUND = -1000 # anything below this we are not interested in \n",
    " #   MAX_BOUND = 700   # anything above too\n",
    "\n",
    "   # image = (image - MIN_BOUND) / (MAX_BOUND - MIN_BOUND)\n",
    "  #  image[image>1] = 1.\n",
    "  #  image[image<0] = 0.\n",
    "  #  return image\n",
    "\n",
    "    \n",
    "def normalize(image):\n",
    "    global MIN_BOUND\n",
    "    global MAX_BOUND\n",
    "    \n",
    "    image = (image - MIN_BOUND) / (MAX_BOUND - MIN_BOUND)\n",
    "    image[image>1] = 1.\n",
    "    image[image<0] = 0.\n",
    "    return image\n",
    "\n",
    "\n",
    "def zero_center(image):\n",
    "    image = image - PIXEL_MEAN\n",
    "    return image\n",
    "\n",
    "\n",
    "def plot_seq(data, name):\n",
    "    \n",
    "    a, b = 3, 20\n",
    "    data = np.reshape(data, (a, b, 128, 128))\n",
    "    test_data = data\n",
    "    r, c = test_data.shape[0], test_data.shape[1]\n",
    "\n",
    "    cmaps = [['viridis', 'binary'], ['plasma', 'coolwarm'], ['Greens', 'copper']]\n",
    "\n",
    "    heights = [a[0].shape[0] for a in test_data]\n",
    "    widths = [a.shape[1] for a in test_data[0]]\n",
    "\n",
    "    fig_width = 10.  # inches\n",
    "    fig_height = fig_width * sum(heights) / sum(widths)\n",
    "\n",
    "    f, axarr = plt.subplots(r,c, figsize=(fig_width, fig_height),\n",
    "          gridspec_kw={'height_ratios':heights})\n",
    "\n",
    "    for i in range(r):\n",
    "        for j in range(c):\n",
    "            axarr[i, j].imshow(test_data[i][j], cmap='gray')\n",
    "            axarr[i, j].axis('off')\n",
    "    \n",
    "    plt.subplots_adjust(wspace=0, hspace=0, left=0, right=1, bottom=0, top=1)\n",
    "    plt.savefig('{}/{}.png'.format(log_path, name), dpi=1000)\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "# NOT USING THIS NOW\n",
    "def resize_depth_wise(img3d):\n",
    "    '''\n",
    "      Inputs a 3d tensor with uneven depth\n",
    "      Outputs a 3d tensor with even depth, in this case depth=64\n",
    "    '''\n",
    "  \n",
    "  # patient image 3D\n",
    "    p = img3d\n",
    "  # list of 3D slices of p\n",
    "    p_2d = []\n",
    "\n",
    "    depth = 2\n",
    "\n",
    "    n = 0\n",
    "    c = 0\n",
    "\n",
    "    for c in range(70):\n",
    "        img = img3d[:,:,n+depth]\n",
    "        p_2d.append(img)\n",
    "        n = n+depth\n",
    "        c = c+1\n",
    "        \n",
    "    p_3d_d64 = np.array(np.dstack(p_2d))\n",
    "    return p_3d_d64\n"
   ]
  },
  {
   "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": {
    "colab": {},
    "colab_type": "code",
    "id": "rXc6dkXOqPXH"
   },
   "outputs": [],
   "source": [
    "# For debugging\n",
    "\n",
    "img = sitk.ReadImage(training_data_raw + patients[0])\n",
    "img = sitk.GetArrayFromImage(img)\n",
    "img = rs_img(img)\n",
    "print(\"Raw volume size: \", img.shape)\n",
    "\n",
    "img_ess = change_depth_ess(img)\n",
    "img_sss = change_depth_sss(img)\n",
    "img_siz = change_depth_siz(img)\n",
    "\n",
    "img_sss = np.transpose(img_sss)\n",
    "img_ess = np.transpose(img_ess)\n",
    "img_siz = np.transpose(img_siz)\n",
    "\n",
    "print(img_sss.shape, img_ess.shape, img_siz.shape)\n",
    "\n",
    "\n",
    "vols = [img_sss[:60], img_ess[:60], img_siz[:60]]\n",
    "tech = ['sss', 'ess', 'siz']\n",
    "\n",
    "for v, t in zip(vols, tech):\n",
    "    plot_seq(v, t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#img = np.transpose(img)\n",
    "#plot_seq(img[:120], \"raw\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "MAfPEiheqTyb"
   },
   "outputs": [],
   "source": [
    "# Load training data\n",
    "\n",
    "\n",
    "# Get a raw data\n",
    "# Resize\n",
    "\n",
    "\n",
    "depths = []\n",
    "pts = []\n",
    "#y_train_ess = []\n",
    "#ct = 0\n",
    "\n",
    "for ps in tqdm(patients[:]):\n",
    "\n",
    "    #print(\"Image Name\", ps)\n",
    "    img = sitk.ReadImage(training_data_raw + ps)\n",
    "    img = sitk.GetArrayFromImage(img)\n",
    "    \n",
    "    # Resize x,y,z\n",
    "    img = rs_img(img)\n",
    "\n",
    "    # Get depth of each volume\n",
    "    d = img.shape[-1]\n",
    "    depths.append(d)\n",
    "    \n",
    "    # What downsampling technique?\n",
    "    img = change_depth_siz(img)\n",
    "\n",
    "    # Normalize [0, 1]\n",
    "    #img = normalize(img)\n",
    "\n",
    "    pts.append(img)\n",
    "    img=None\n",
    "    #y_train_ess.append(y_train[ct])\n",
    "    #ct+=1\n",
    "\n",
    "# Convert to numpy array\n",
    "train_data = np.array(pts)\n",
    "print(train_data.shape)\n",
    "\n",
    "# Clear memory\n",
    "pts = None\n",
    "\n",
    "\n",
    "print(\"Min depth:\", min(depths))"
   ]
  },
  {
   "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": [
    "#y_train_ess = np.array(y_train_ess)\n",
    "#print(y_train_ess.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#np.save('{}/y_train_clef_ess.npy'.format(dataset_path), y_train_ess)"
   ]
  },
  {
   "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": [
    "# Get count of volumes < 64\n",
    "count = 0\n",
    "\n",
    "for i in depths:\n",
    "    if i < 64:\n",
    "        count+=1\n",
    "\n",
    "print(count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "######################################################################\n",
    "# Test data path\n",
    "#INPUT_FOLDER = 'TestSet/'  \n",
    "#test_data_raw = os.path.join(dataset_path, INPUT_FOLDER)\n",
    "\n",
    "#patients_test = sorted(os.listdir(test_data_raw))\n",
    "#print(len(patients_test))\n",
    "#print(patients_test[:2])\n",
    "\n",
    "# Load test data\n",
    "#pts_test = []\n",
    "\n",
    "#for ps in tqdm(patients_test[:]):\n",
    "\n",
    "    #print(\"Image Name\", ps)\n",
    "#    img = sitk.ReadImage(test_data_raw + ps)\n",
    "#    img = sitk.GetArrayFromImage(img)\n",
    "    \n",
    "    # Resize x,y,z\n",
    "#    img = rs_img(img)\n",
    "\n",
    "    # What downsampling technique?\n",
    "#    img = change_depth_sss(img)\n",
    "\n",
    "#    pts_test.append(img)\n",
    "#    img=None\n",
    "\n",
    "# Convert to numpy array\n",
    "#test_data = np.array(pts_test)\n",
    "#test_data.shape\n",
    "######################################################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "img = train_data[0]\n",
    "img.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.min(img), np.max(img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.imshow(img[:,:,25], cmap='gray')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "img[:,:,30]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "nxBD523-vVGL"
   },
   "outputs": [],
   "source": [
    "# Get these values for preprocessing\n",
    "\n",
    "MIN_BOUND = np.min(train_data)\n",
    "MAX_BOUND = np.max(train_data)\n",
    "PIXEL_MEAN = np.mean(train_data)\n",
    "\n",
    "print(\"Min\", MIN_BOUND)\n",
    "print(\"Min\", MAX_BOUND)\n",
    "print(\"Mean\", PIXEL_MEAN)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "g0Y30CY6xnoU"
   },
   "outputs": [],
   "source": [
    "# Normalize\n",
    "x_train = normalize(train_data)\n",
    "\n",
    "np.max(x_train), np.min(x_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "VLW1lFCZ6nsJ"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "jL0V8TFS7C0e"
   },
   "outputs": [],
   "source": [
    "#https://github.com/hasibzunair/uniformizing-3D/blob/master/others/5th_place_submission/preprocessing/normalization_and_zero_center.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "JCgI_KJqxnut"
   },
   "outputs": [],
   "source": [
    "# Zero center data\n",
    "#x_train_zero = zero_center(x_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "k2GXsdOY4Icv"
   },
   "outputs": [],
   "source": [
    "# After processing\n",
    "\n",
    "MIN_BOUND = np.min(x_train)\n",
    "MAX_BOUND = np.max(x_train)\n",
    "PIXEL_MEAN = np.mean(x_train)\n",
    "\n",
    "print(\"Min\", MIN_BOUND)\n",
    "print(\"Max\", MAX_BOUND)\n",
    "print(\"Mean\", PIXEL_MEAN)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "vWcOGpbexoAX"
   },
   "outputs": [],
   "source": [
    "# Save training and test data\n",
    "#np.save('{}/x_test.npy'.format(dataset_path), x_test)\n",
    "np.save('{}/x_train_siz_norm.npy'.format(dataset_path), x_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "authorship_tag": "ABX9TyPr0flgkvo9kiWT+NyIkSui",
   "collapsed_sections": [],
   "machine_shape": "hm",
   "name": "data_process_clef19.ipynb",
   "provenance": []
  },
  "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}