preprocessing.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Preprocessing\n",
    "\n",
    "Modifico tutte le CT, in modo che siano pronte per i modelli."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "D:\\kits19\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "os.chdir(\"D:\\kits19\")\n",
    "cwd = os.getcwd()\n",
    "print(cwd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import nibabel as nib\n",
    "import skimage.transform\n",
    "from scipy.ndimage import zoom\n",
    "from skimage import exposure\n",
    "import cv2\n",
    "from tqdm import tqdm\n",
    "from PIL import Image\n",
    "\n",
    "# Set numpy to print only 2 decimal digits for neatness\n",
    "np.set_printoptions(precision=2, suppress=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_path = \"data/case_\"\n",
    "imaging_fname = \"/imaging.nii.gz\"\n",
    "segmentation_fname = \"/segmentation.nii.gz\"\n",
    "\n",
    "class Patient:\n",
    "  def __init__(self, number):\n",
    "      self.number = number\n",
    "      \n",
    "      self.imaging_path = self.get_im_data_path()\n",
    "      self.imaging = nib.load(self.imaging_path)\n",
    "      \n",
    "      if number < 210: # segmentation file only exists for non-submission cases\n",
    "        self.segmentation_path = self.get_seg_data_path()\n",
    "        self.segmentation = nib.load(self.segmentation_path)\n",
    "\n",
    "  def get_im_data_path(self):\n",
    "      '''\n",
    "      returns path to imaging file\n",
    "      '''\n",
    "      out = \"00000\"\n",
    "\n",
    "      out = out[len(str(self.number)):]\n",
    "      out += str(self.number)\n",
    "      return data_path + out + imaging_fname\n",
    "  \n",
    "  def get_seg_data_path(self):\n",
    "      '''\n",
    "      returns path to segmentation file\n",
    "      '''\n",
    "      out = \"00000\"\n",
    "\n",
    "      out = out[len(str(self.number)):]\n",
    "      out += str(self.number)\n",
    "      return data_path + out + segmentation_fname\n",
    "\n",
    "  def rr(self, target_file, target_resolution=[1,1,1], target_shape=[192,192,192]):\n",
    "    '''\n",
    "    Target file can be either self.imaging or self.segmentation\n",
    "    Function that returns reshaped and resized target block\n",
    "    ''' \n",
    "    target_fig = target_file.get_fdata()\n",
    "\n",
    "    # x,y,z\n",
    "    vox_dim = (target_file.header['pixdim'][2], target_file.header['pixdim'][3], target_file.header['pixdim'][1])\n",
    "\n",
    "    scale_vector = (vox_dim[0]/target_resolution[0],\n",
    "                    vox_dim[1]/target_resolution[1],\n",
    "                    vox_dim[2]/target_resolution[2])\n",
    "\n",
    "    \n",
    "\n",
    "    iso_target_fig = skimage.transform.rescale(target_fig, scale_vector, order=3, preserve_range=True,  mode='constant')\n",
    "    \n",
    "    # print(iso_target_fig.dtype) # float64\n",
    "    \n",
    "    factors = ( target_shape[0]/iso_target_fig.shape[0],\n",
    "                target_shape[1]/iso_target_fig.shape[1],\n",
    "                target_shape[2]/iso_target_fig.shape[2],)\n",
    "\n",
    "    rr_target_cube = zoom(iso_target_fig, factors, order=3, mode='nearest')\n",
    "\n",
    "    # print(rr_target_cube.dtype) # float64\n",
    "\n",
    "    # rr = rescaled and reshaped\n",
    "    # rr_target = nib.Nifti1Image(rr_target_fig, target_file.affine)\n",
    "\n",
    "    # # setto le dimensioni manualmente, sono abbastanza sicuro che il rescaling sia avvenuto correttamente\n",
    "\n",
    "    # for i in range(3):\n",
    "    #   rr_target.header['pixdim'][i+1] = target_resolution[i]\n",
    "\n",
    "    # for i in range(3):\n",
    "    #   rr_target.affine[i][2-i] = -target_resolution[i]\n",
    "\n",
    "    return rr_target_cube\n",
    "\n",
    "  def process_imaging(self, target_resolution=[1,1,1], target_shape=[192,256,256]):\n",
    "    '''\n",
    "    function that returns reshaped, resized, normalized imaging block\n",
    "    '''\n",
    "\n",
    "    rr_imaging = self.rr(self.imaging, target_resolution, target_shape)\n",
    "    output = cv2.normalize(rr_imaging, None, alpha = 0, beta = 255, norm_type = cv2.NORM_MINMAX, dtype = cv2.CV_8UC1)\n",
    "    return output\n",
    "\n",
    "  def process_segmentation(self, target_resolution=[1,1,1], target_shape=[192,256,256]):\n",
    "    '''\n",
    "    function that returns reshaped, resized segmentation block\n",
    "    '''\n",
    "\n",
    "    output = self.rr(self.segmentation, target_resolution, target_shape)\n",
    "\n",
    "    # might break things (it does, kinda)\n",
    "    #output = cv2.normalize(rr_segmentation, None, alpha = 0, beta = 3, norm_type = cv2.NORM_MINMAX, dtype = cv2.CV_8UC1)\n",
    "    \n",
    "    output = np.rint(output)\n",
    "    output = output.astype('uint8')\n",
    "\n",
    "    return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def imshow_from_list(imgs_and_segs):\n",
    "  '''\n",
    "  helper function that given a list of tuples returns img and seg figs next to each other\n",
    "  '''\n",
    "  n = len(imgs_and_segs)\n",
    "  fig = plt.figure(figsize=(16, n*8))\n",
    "  for i in range(0,2*n,2):\n",
    "    a = fig.add_subplot(n,2,i+1)\n",
    "    imgplot = plt.imshow(imgs_and_segs[i//2][0], cmap='gray')\n",
    "    plt.title(\"Height: {}\".format(i))\n",
    "    a = fig.add_subplot(n,2,i+2)\n",
    "    imgplot = plt.imshow(imgs_and_segs[i//2][1])\n",
    "    \n",
    "  plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_number(n):\n",
    "  '''\n",
    "  returns num padded with zeros\n",
    "  '''\n",
    "  out = \"00000\"\n",
    "\n",
    "  out = out[len(str(n)):]\n",
    "  out += str(n)\n",
    "  return out"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "Iterate over all the cases, get images, kidney and tumor masks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 167/167 [2:12:13<00:00, 47.51s/it]  \n"
     ]
    }
   ],
   "source": [
    "# get train/test data\n",
    "\n",
    "clahe_img = cv2.createCLAHE (clipLimit = 2.0, tileGridSize = (8, 8))\n",
    "\n",
    "for i in tqdm(range(1,168)): # 168:210 = 80:100\n",
    "  fig_path = '//processed_data//sub_images'\n",
    "  kidney_path = '//processed_data//test_kidney_labels'\n",
    "  tumor_path = '//processed_data//test_tumor_labels'\n",
    "  combined_mask_path = 'D:\\\\kits19\\\\processed_data\\\\combined_labels'\n",
    "\n",
    "  pat = Patient(i)\n",
    "  #img_cube = pat.process_imaging(target_shape=[192, 256, 256])\n",
    "  seg_cube = pat.process_segmentation(target_shape=[192, 256, 256])\n",
    "\n",
    "  for j in range(191):\n",
    "    # name_im = fig_path + '/case_' + get_number(i) + '_im_' + get_number(j) + '.png'\n",
    "    # name_seg = kidney_path + '/case_' + get_number(i) + '_seg_' + get_number(j) + '.png'\n",
    "    # name_tum = tumor_path + '/case_' + get_number(i) + '_tum_' + get_number(j) + '.png'\n",
    "\n",
    "    name_combined = combined_mask_path + '/case_' + get_number(i) + '_comb_' + get_number(j) + '.png'\n",
    "    \n",
    "    #apply clahe on imaging for better results\n",
    "    # img_slice = Image.fromarray(clahe_img.apply(img_cube[j,:,:]))\n",
    "    # img_slice.save(name_im)\n",
    "    \n",
    "    # # create kidney mask\n",
    "    # seg_cube_at_j = seg_cube[j,:,:]\n",
    "    # seg_cube_at_j[seg_cube_at_j>1] = 1\n",
    "    # seg_cube_at_j = seg_cube_at_j*255\n",
    "    # seg_pic = Image.fromarray(seg_cube_at_j)\n",
    "    # seg_pic.save(name_seg)\n",
    "\n",
    "    # create tumor mask\n",
    "    # tum_cube_at_j = seg_cube[j,:,:]\n",
    "    # tum_cube_at_j[tum_cube_at_j==1] = 0 # set kidney values to 0\n",
    "    # tum_cube_at_j[tum_cube_at_j==2] = 1 # set tumor values to 1\n",
    "    # tum_cube_at_j = tum_cube_at_j*255\n",
    "    # tum_pic = Image.fromarray(tum_cube_at_j)\n",
    "    # tum_pic.save(name_tum)\n",
    "\n",
    "    # create combined mask (tumor and kidney)\n",
    "    # this time image will have low contrast, (np.unique(comb_pic) >> [0,1,2]) so that mask is already encoded\n",
    "    comb_slice_at_j = seg_cube[j,:,:]\n",
    "    comb_pic = Image.fromarray(comb_slice_at_j)\n",
    "    comb_pic.save(name_combined)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# verify results\n",
    "pat = Patient(1)\n",
    "seg_cube = pat.process_segmentation(target_shape=[192, 256, 256])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'D:\\\\kits19'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "comb_slice_at_j = seg_cube[84,:,:]\n",
    "\n",
    "print(np.unique(comb_slice_at_j))\n",
    "\n",
    "plt.imshow(comb_slice_at_j, cmap='gray')\n",
    "\n",
    "comb_pic = Image.fromarray(comb_slice_at_j*127)\n",
    "comb_pic.save('TEST3.png')\n",
    "os.getcwd()"
   ]
  }
 ],
 "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.10.9 (tags/v3.10.9:1dd9be6, Dec  6 2022, 20:01:21) [MSC v.1934 64 bit (AMD64)]"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "602bbe8e8fe3127dc2d2bb8f57c49cfbb507be2cc0e090f10eb4c4d0af354b8b"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}