final_aug_lung.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# https://www.kaggle.com/code/bguberfain/elastic-transform-for-data-augmentation/notebook\n",
    "# https://gist.github.com/erniejunior/601cdf56d2b424757de5\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "import time\n",
    "import random\n",
    "import numpy as np # linear algebra\n",
    "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n",
    "import skimage.io\n",
    "from skimage import color\n",
    "from skimage import io\n",
    "import glob\n",
    "import cv2\n",
    "from scipy.ndimage.interpolation import map_coordinates\n",
    "from scipy.ndimage.filters import gaussian_filter\n",
    "import matplotlib.pyplot as plt\n",
    "import staintools\n",
    "from tqdm import tqdm\n",
    "import tifffile\n",
    "import sys\n",
    "import os\n",
    "import numpy as np\n",
    "from scipy import interpolate\n",
    "from scipy.ndimage import morphology\n",
    "from scipy.stats import multivariate_normal\n",
    "from PIL import Image, ImageDraw\n",
    "from cv2 import GaussianBlur, blur, getPerspectiveTransform, warpPerspective\n",
    "from hashlib import blake2s\n",
    "import imgaug as ia\n",
    "import imgaug.augmenters as iaa\n",
    "from deconvolution import Deconvolution\n",
    "import deconvolution.pixeloperations as po\n",
    "from albumentations.augmentations.transforms import HorizontalFlip\n",
    "from albumentations.augmentations.transforms import VerticalFlip\n",
    "from albumentations.augmentations.transforms import Transpose\n",
    "import torch\n",
    "from torch import nn\n",
    "import torch.cuda.amp as amp\n",
    "from torch.utils.data import Dataset\n",
    "from torch.utils.data import DataLoader\n",
    "from torch.utils.data import RandomSampler \n",
    "from torch.utils.data import SequentialSampler\n",
    "import torch.nn.functional as F\n",
    "from torch.optim.lr_scheduler import StepLR\n",
    "import tifffile\n",
    "from fastai.vision.all import *\n",
    "import Augmentor\n",
    "\n",
    "from collections import defaultdict\n",
    "sys.path.append(\"/home/lakshita/somusan/hubmap_kaggle/hubmap_data/histopath_failure_modes\")\n",
    "from image_manipulation import img_manip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(48,\n",
       " kidney            99\n",
       " prostate          93\n",
       " largeintestine    58\n",
       " spleen            53\n",
       " lung              48\n",
       " Name: organ, dtype: int64)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "TRAIN_CSV = \"/home/lakshita/somusan/hubmap_kaggle/hubmap_data/hubmap-organ-segmentation/train.csv\"\n",
    "df = pd.read_csv(TRAIN_CSV)\n",
    "\n",
    "df_lung = df[df['organ'] == 'lung'].reset_index()\n",
    "df_lung.__len__(), df['organ'].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rle_decode(mask_rle, shape):\n",
    "    '''\n",
    "    mask_rle: run-length as string formated (start length)\n",
    "    shape: (height,width) of array to return \n",
    "    Returns numpy array, 1 - mask, 0 - background\n",
    "\n",
    "    '''\n",
    "    s = mask_rle.split()\n",
    "    starts, lengths = [np.asarray(x, dtype=int) for x in (s[0:][::2], s[1:][::2])]\n",
    "    starts -= 1\n",
    "    ends = starts + lengths\n",
    "    img = np.zeros(shape[0]*shape[1], dtype=np.uint8)\n",
    "    for lo, hi in zip(starts, ends):\n",
    "        img[lo:hi] = 1\n",
    "    return img.reshape(shape).T\n",
    "\n",
    "# ref.: https://www.kaggle.com/stainsby/fast-tested-rle\n",
    "def rle_encode(img):\n",
    "    '''\n",
    "    img: numpy array, 1 - mask, 0 - background\n",
    "    Returns run length as string formated\n",
    "    '''\n",
    "    pixels = img.flatten()\n",
    "    pixels = np.concatenate([[0], pixels, [0]])\n",
    "    runs = np.where(pixels[1:] != pixels[:-1])[0] + 1\n",
    "    runs[1::2] -= runs[::2]\n",
    "    return ' '.join(str(x) for x in runs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def horizontal_flip(image, mask):\n",
    "\n",
    "    transform = HorizontalFlip(p=1.0)\n",
    "    augmented_image = transform(image=image, mask=mask)\n",
    "    image  = augmented_image['image']\n",
    "    mask  = augmented_image['mask']\n",
    "    return image, mask\n",
    "\n",
    "def vertical_flip(image, mask):\n",
    "\n",
    "    transform = VerticalFlip(p=1.0)\n",
    "    augmented_image = transform(image=image, mask=mask)\n",
    "    image  = augmented_image['image']\n",
    "    mask  = augmented_image['mask']\n",
    "    return image, mask\n",
    "\n",
    "\n",
    "def bubble_aug(image, mask):\n",
    "\n",
    "    im_pil = Image.fromarray(image)\n",
    "    img_with_bubbles = img_manip.add_bubbles(im_pil, alpha=0.55, maxWidth = 120, nBubbles = 150)\n",
    "    image = np.array(img_with_bubbles)\n",
    "\n",
    "    return image, mask\n",
    "\n",
    "\n",
    "def stain_aug(image, mask):\n",
    "\n",
    "    im_pil = Image.fromarray(image)\n",
    "    image_with_stain = img_manip.add_stain(im_pil, adjFactor = [1.5, 0.2, 1.0],scaleMax = [3,3,1.5], scaleMin = [1.25,1.25,1],random_seed = None)\n",
    "    image = np.array(image_with_stain)\n",
    "\n",
    "    return image, mask\n",
    "\n",
    "def sectioning_aug(image, mask):\n",
    "\n",
    "    im_pil = Image.fromarray(image)\n",
    "    image_with_sectioning = img_manip.add_sectioning(im_pil,endEdge = 2, nPts=2)\n",
    "    image = np.array(image_with_sectioning)\n",
    "\n",
    "    return image, mask\n",
    "\n",
    "def clahe_aug(image, mask):\n",
    "    \n",
    "    h,w= mask.shape\n",
    "\n",
    "    seq = iaa.Sequential([\n",
    "        iaa.AllChannelsCLAHE(clip_limit=(1, 10))\n",
    "    ], random_order=True)\n",
    "\n",
    "    image, segmaps = seq(image=image, segmentation_maps=mask.reshape(1,h,w,1))\n",
    "    segmaps = segmaps.reshape(h,w)\n",
    "\n",
    "    return image, segmaps\n",
    "\n",
    "def transpose_flip(image, mask):\n",
    "    transform = Transpose(p=1.0)\n",
    "    augmented_image = transform(image=image, mask=mask)\n",
    "    image  = augmented_image['image']\n",
    "    mask  = augmented_image['mask']\n",
    "    return image, mask\n",
    "\n",
    "def image_ditails(image, message):\n",
    "    \n",
    "    print(\"\\n =----------------------------\")\n",
    "    print(message)\n",
    "    print(\"image type\",type(image))\n",
    "    print(\"image dtype\",image.dtype)\n",
    "    print(\"shape\",image.shape)\n",
    "    print(\"\\n =----------------------------=\")\n",
    "    \n",
    "\n",
    "def elastic_deform(image, mask):\n",
    "    \"\"\"\n",
    "    i/p image shape: (3000,3000,3)\n",
    "    i/p mask shape: (3000,3000,1)\n",
    "\n",
    "    o/p image shape: (3000,3000,3)\n",
    "    o/p mask shape: (3000,3000,1)\n",
    "    \"\"\"\n",
    "    \n",
    "    p = Augmentor.DataPipeline([[np.array(image),np.array(mask)]])\n",
    "\n",
    "    p.shear(1, max_shear_left = 3, max_shear_right = 3)\n",
    "    p.skew(0.4, 0.5)\n",
    "\n",
    "    \n",
    "    images_aug = p.sample(1)\n",
    "    \n",
    "    augmented_image = images_aug[0][0]\n",
    "    augmented_mask = images_aug[0][1]\n",
    "    # print(\"inside elastic deform\", augmented_mask.shape)\n",
    "    # print(\"inside elastic deform\", augmented_image.shape)\n",
    "\n",
    "    return augmented_image, augmented_mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "image_size = 512\n",
    "TRAIN = '/home/lakshita/somusan/hubmap_kaggle/nbs/hubmap-22-aug-pixel-size'\n",
    "class HubmapDataset(Dataset):\n",
    "    def __init__(self, df, augment=None):\n",
    "\n",
    "        self.df = df\n",
    "        self.augment = augment\n",
    "        self.length = len(self.df)\n",
    "        self.organ_to_label = {'kidney' : 0,\n",
    "                               'prostate' : 1,\n",
    "                               'largeintestine' : 2,\n",
    "                               'spleen' : 3,\n",
    "                               'lung' : 4}\n",
    "\n",
    "    def __str__(self):\n",
    "        string = ''\n",
    "        string += '\\tlen = %d\\n' % len(self)\n",
    "\n",
    "        d = self.df.organ.value_counts().to_dict()\n",
    "        for k in ['kidney', 'prostate', 'largeintestine', 'spleen', 'lung']:\n",
    "            string +=  '%24s %3d (%0.3f) \\n'%(k, d.get(k,0), d.get(k,0)/len(self.df))\n",
    "        return string\n",
    "\n",
    "    def __len__(self):\n",
    "        return self.length\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        d = self.df.iloc[index]\n",
    "        img_height = self.df.loc[index, 'img_height']\n",
    "        img_width = self.df.loc[index, 'img_width']\n",
    "        organ = self.organ_to_label[d.organ]\n",
    "\n",
    "        image = cv2.cvtColor(cv2.imread(os.path.join(TRAIN, f'{d.id}.png')), cv2.COLOR_BGR2RGB).astype(np.uint8)\n",
    "        \n",
    "        rle_mask = self.df.loc[index, 'rle']\n",
    "        mask = rle_decode(rle_mask, (img_height, img_width)).astype(np.uint8)\n",
    "        # mask = np.expand_dims(mask, axis = 2)\n",
    "\n",
    "        if self.augment is not None:\n",
    "            image, mask = self.augment(image, mask, organ)\n",
    "\n",
    "        # mask = np.expand_dims(mask, axis = 0)\n",
    "        # print(\"inside dataclass\")\n",
    "        # print(image.shape, mask.shape)\n",
    "        r ={}\n",
    "        r['index']= index\n",
    "        r['image'] = image\n",
    "        r['mask' ] = mask\n",
    "        r['id'] = d.id\n",
    "\n",
    "        return r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_augment5b(image, mask, organ):\n",
    "    \n",
    "    for fn in np.random.choice([\n",
    "        lambda image, mask: (image, mask),\n",
    "        lambda image, mask: horizontal_flip(image, mask),\n",
    "        lambda image, mask: transpose_flip(image, mask),\n",
    "        lambda image, mask: vertical_flip(image, mask),\n",
    "    ], 2, p=[0.1,0.3, 0.3, 0.3]): image, mask = fn(image, mask)\n",
    "\n",
    "    for fn in np.random.choice([\n",
    "        lambda image, mask: (image, mask),\n",
    "        lambda image, mask: elastic_deform(image, mask),\n",
    "    ], 1, p=[0.25, 0.75]): image, mask = fn(image, mask)\n",
    "\n",
    "\n",
    "    for fn in np.random.choice([\n",
    "        lambda image, mask: (image, mask),\n",
    "        lambda image, mask: clahe_aug(image, mask),\n",
    "        lambda image, mask: sectioning_aug(image, mask),\n",
    "        lambda image, mask: stain_aug(image, mask),\n",
    "    ], 2, p=[0.35, 0.15, 0.3, 0.2]): image, mask = fn(image, mask)\n",
    "\n",
    "    for fn in np.random.choice([\n",
    "        lambda image, mask: (image, mask),\n",
    "        lambda image, mask: bubble_aug(image, mask),\n",
    "    ], 1, p=[0.4, 0.6]): image, mask = fn(image, mask)\n",
    "\n",
    "    return image, mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"/home/lakshita/somusan/hubmap_kaggle/hubmap_data/hubmap-organ-segmentation/train.csv\")\n",
    "df = df[df['organ']=='lung'].reset_index()\n",
    "train_dataset = HubmapDataset(df, train_augment5b)\n",
    "\n",
    "\n",
    "# train_loader = torch.utils.data.DataLoader(\n",
    "#                dataset=train_dataset,\n",
    "#                batch_size=4,\n",
    "#                shuffle=False,\n",
    "#                num_workers=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 40/40 [3:40:45<00:00, 331.13s/it]  \n"
     ]
    }
   ],
   "source": [
    "# img_ = train_dataset[0]['image']\n",
    "# mask_ = train_dataset[0]['mask']\n",
    "# img_.shape, mask_.shape\n",
    "from tqdm import tqdm\n",
    "\n",
    "dir = \"/home/lakshita/somusan/hubmap_kaggle/nbs/hubmap-22-aug-pixel-size\"\n",
    "\n",
    "dest_dir_img = '/home/lakshita/somusan/hubmap_kaggle/nbs/aug_lung_data/image'\n",
    "dest_dir_mask = '/home/lakshita/somusan/hubmap_kaggle/nbs/aug_lung_data/mask'\n",
    "\n",
    "os.makedirs(dest_dir_img, exist_ok=True) \n",
    "os.makedirs(dest_dir_mask, exist_ok=True) \n",
    "\n",
    "\n",
    "\n",
    "lung_idx = [i for i in range(len(df))]\n",
    "for idx in tqdm(np.random.choice(lung_idx, 40)):\n",
    "    img_ = train_dataset[idx]['image']\n",
    "    mask_ = train_dataset[idx]['mask']\n",
    "    id_ = train_dataset[idx]['id']\n",
    "\n",
    "    fname_img = dest_dir_img + \"/\" + str(id_) + \".png\"\n",
    "    fname_mask = dest_dir_mask + \"/\" + str(id_) + \".png\"\n",
    "\n",
    "    cv2.imwrite(fname_img, img_)\n",
    "    cv2.imwrite(fname_mask, mask_)\n",
    "\n",
    "    # plt.figure(figsize=(14,16))\n",
    "    # plt.imshow(img_);plt.imshow(mask_, alpha=0.3)\n",
    "    # plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Image Name Fix:\n",
    "- name fix\n",
    "- add new ids to the csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "32it [00:00, 11961.30it/s]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "take 1 img, take its index and file name, then new name = file_name + index\n",
    "\"\"\"\n",
    "import os\n",
    "import glob\n",
    "from tqdm import tqdm\n",
    "\n",
    "# os.mkdirs(\"/home/lakshita/somusan/hubmap_kaggle/nbs/aug_lung_data/img\")\n",
    "img_file = \"/home/lakshita/somusan/hubmap_kaggle/nbs/aug_lung_data/image\"\n",
    "msk_file = \"/home/lakshita/somusan/hubmap_kaggle/nbs/aug_lung_data/mask\"\n",
    "for idx, (img_, msk_) in tqdm(enumerate(zip(glob.glob(img_file+\"/*\"), glob.glob(msk_file+\"/*\")))):\n",
    "    new_id = img_.split('/')[-1].split(\".\")[0] + str(idx)\n",
    "    new_img = img_file + \"/\" + new_id + \".png\"\n",
    "    new_msk = msk_file + \"/\" + new_id + \".png\"\n",
    "\n",
    "    os.rename(img_,new_img) \n",
    "    os.rename(msk_,new_msk) \n",
    "    \n",
    "\n",
    "\n",
    "# deleted 823101"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import glob\n",
    "import os\n",
    "import cv2\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "img_file = \"/home/lakshita/somusan/hubmap_kaggle/nbs/aug_lung_data/image\"\n",
    "msk_file = \"/home/lakshita/somusan/hubmap_kaggle/nbs/aug_lung_data/mask\"\n",
    "\n",
    "total_msk_paths = glob.glob(msk_file+\"/*\")\n",
    "total_img_paths = glob.glob(img_file+\"/*\")\n",
    "\n",
    "data_source = [\"HPA\" for i in range(len(total_img_paths))]\n",
    "img_height = [cv2.imread(i).shape[0] for i in total_img_paths]\n",
    "img_width = [cv2.imread(i).shape[1] for i in total_img_paths]\n",
    "pixel_size = [0.4 for i in range(len(total_img_paths))]\n",
    "tissue_thickness = [4 for i in range(len(total_img_paths))]\n",
    "age = [22.0 for i in range(len(total_img_paths))]\n",
    "sex = [\"Male\" for i in range(len(total_img_paths))]\n",
    "organ = [\"lung\" for i in range(len(total_img_paths))]\n",
    "id_ = []\n",
    "for i in total_img_paths:\n",
    "    id_.append(int(i.split(\"/\")[-1].split('.')[0]))\n",
    "    \n",
    "rle = [rle_encode(cv2.imread(total_msk_paths[i],0)) for i in range(len(total_img_paths))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>id</th>\n",
       "      <th>organ</th>\n",
       "      <th>data_source</th>\n",
       "      <th>img_height</th>\n",
       "      <th>img_width</th>\n",
       "      <th>pixel_size</th>\n",
       "      <th>tissue_thickness</th>\n",
       "      <th>rle</th>\n",
       "      <th>age</th>\n",
       "      <th>sex</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>311399</td>\n",
       "      <td>lung</td>\n",
       "      <td>HPA</td>\n",
       "      <td>3000</td>\n",
       "      <td>3000</td>\n",
       "      <td>0.4</td>\n",
       "      <td>4</td>\n",
       "      <td>1345440 2 1348438 2 1348442 1 1351436 2 135143...</td>\n",
       "      <td>22.0</td>\n",
       "      <td>Male</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>50867</td>\n",
       "      <td>lung</td>\n",
       "      <td>HPA</td>\n",
       "      <td>3000</td>\n",
       "      <td>3000</td>\n",
       "      <td>0.4</td>\n",
       "      <td>4</td>\n",
       "      <td>2200408 26 2203404 36 2206397 48 2209396 53 22...</td>\n",
       "      <td>22.0</td>\n",
       "      <td>Male</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>12204</td>\n",
       "      <td>lung</td>\n",
       "      <td>HPA</td>\n",
       "      <td>3000</td>\n",
       "      <td>3000</td>\n",
       "      <td>0.4</td>\n",
       "      <td>4</td>\n",
       "      <td>5240485 2 5240489 2 5243484 13 5246483 15 5249...</td>\n",
       "      <td>22.0</td>\n",
       "      <td>Male</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2325210</td>\n",
       "      <td>lung</td>\n",
       "      <td>HPA</td>\n",
       "      <td>3000</td>\n",
       "      <td>3000</td>\n",
       "      <td>0.4</td>\n",
       "      <td>4</td>\n",
       "      <td>1483636 14 1486636 15 1489633 3 1489637 12 148...</td>\n",
       "      <td>22.0</td>\n",
       "      <td>Male</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>187828</td>\n",
       "      <td>lung</td>\n",
       "      <td>HPA</td>\n",
       "      <td>3000</td>\n",
       "      <td>3000</td>\n",
       "      <td>0.4</td>\n",
       "      <td>4</td>\n",
       "      <td>1685219 4 1688218 6 1691216 8 1694214 11 16972...</td>\n",
       "      <td>22.0</td>\n",
       "      <td>Male</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        id organ data_source  img_height  img_width  pixel_size  \\\n",
       "0   311399  lung         HPA        3000       3000         0.4   \n",
       "1    50867  lung         HPA        3000       3000         0.4   \n",
       "2    12204  lung         HPA        3000       3000         0.4   \n",
       "3  2325210  lung         HPA        3000       3000         0.4   \n",
       "4   187828  lung         HPA        3000       3000         0.4   \n",
       "\n",
       "   tissue_thickness                                                rle   age  \\\n",
       "0                 4  1345440 2 1348438 2 1348442 1 1351436 2 135143...  22.0   \n",
       "1                 4  2200408 26 2203404 36 2206397 48 2209396 53 22...  22.0   \n",
       "2                 4  5240485 2 5240489 2 5243484 13 5246483 15 5249...  22.0   \n",
       "3                 4  1483636 14 1486636 15 1489633 3 1489637 12 148...  22.0   \n",
       "4                 4  1685219 4 1688218 6 1691216 8 1694214 11 16972...  22.0   \n",
       "\n",
       "    sex  \n",
       "0  Male  \n",
       "1  Male  \n",
       "2  Male  \n",
       "3  Male  \n",
       "4  Male  "
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv(\"/home/lakshita/somusan/hubmap_kaggle/hubmap_data/hubmap-organ-segmentation/train.csv\")\n",
    "# df.head()\n",
    "\n",
    "lung_df_dict = {\n",
    "    \"id\": id_,\n",
    "    \"organ\": organ,\n",
    "    \"data_source\": data_source,\n",
    "    \"img_height\": img_height,\n",
    "    \"img_width\": img_width,\n",
    "    \"pixel_size\": pixel_size,\n",
    "    \"tissue_thickness\": tissue_thickness,\n",
    "    \"rle\": rle,\n",
    "    \"age\": age,\n",
    "    \"sex\":sex\n",
    "}\n",
    "\n",
    "df_lung = pd.DataFrame.from_dict(lung_df_dict)\n",
    "# df_lung.drop('Unnamed: 0', axis=0, inplace=True) \n",
    "# df_lung.head()\n",
    "\n",
    "df_lung.to_csv('/home/lakshita/somusan/hubmap_kaggle/nbs/aug_lung_data/aug_lung.csv', index=False)\n",
    "\n",
    "df_temp  = pd.read_csv(\"/home/lakshita/somusan/hubmap_kaggle/nbs/aug_lung_data/aug_lung.csv\")\n",
    "df_temp.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"/home/lakshita/somusan/hubmap_kaggle/hubmap_data/hubmap-organ-segmentation/train.csv\")\n",
    "df_3 = pd.concat([df, df_lung], axis=0)\n",
    "df_3.to_csv('/home/lakshita/somusan/hubmap_kaggle/nbs/aug_lung_data/aug_lug_all_train.csv', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "# All lungs\n",
    "lung_norma = df[df['organ']=='lung']\n",
    "only_lung = pd.concat([lung_norma, df_lung], axis=0)\n",
    "only_lung.to_csv('/home/lakshita/somusan/hubmap_kaggle/nbs/aug_lung_data/only_lung.csv', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "original_lung_ids = []\n",
    "\n",
    "for i in df_lung.iterrows():\n",
    "    id_str = str(i[1].id)\n",
    "    # print(id_str)\n",
    "    if(len(id_str)) == 4:\n",
    "        original_lung_ids.append(str(id_str[0:3]))\n",
    "        # print(\"one from 4\")\n",
    "    elif(len(id_str)) == 5:\n",
    "        original_lung_ids.append(str(id_str[0:3]))\n",
    "        original_lung_ids.append(str(id_str[0:4]))\n",
    "        # print(\"one from 5\")\n",
    "    elif(len(id_str)) == 6:\n",
    "        original_lung_ids.append(str(id_str[0:4]))\n",
    "        original_lung_ids.append(str(id_str[0:5]))\n",
    "        # print(\"one from 6\")\n",
    "    elif(len(id_str)) == 7:\n",
    "        original_lung_ids.append(str(id_str[0:5]))\n",
    "        # print(\"one from 7\")\n",
    "\n",
    "augmented_id = []\n",
    "for i in original_lung_ids:\n",
    "    # print(i)\n",
    "    if int(i) in df[df['organ']=='lung'].id.to_list():\n",
    "        augmented_id.append(i)\n",
    "\n",
    "with open('/home/lakshita/somusan/hubmap_kaggle/nbs/aug_lung_data/lung_aug_ids.txt', 'w') as filehandle:\n",
    "    for listitem in augmented_id:\n",
    "        filehandle.write('%s\\n' % listitem)\n",
    "\n",
    "\n",
    "\n",
    "# org_lung_size_set = set()\n",
    "\n",
    "# for j in range(len(df[df['organ']=='lung'].id)):\n",
    "#     org_lung_size_set.add(len(str(df[df['organ']=='lung'].id.iloc[j])))\n",
    "\n",
    "# print(org_lung_size_set)\n",
    "# size_set = set()\n",
    "# for i in os.listdir(\"/home/lakshita/somusan/hubmap_kaggle/nbs/aug_lung_data/image\"):\n",
    "#     size_set.add(len(i.split('.')[0]))\n",
    "\n",
    "# print(size_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# df[df['organ']=='lung'].id.to_list()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "img_temp = plt.imread(\"/home/lakshita/somusan/hubmap_kaggle/hubmap_data/hubmap-organ-segmentation/train_images/5086.tiff\")\n",
    "msk_temp = plt.imread(\"/home/lakshita/somusan/hubmap_kaggle/hubmap_data/mask_png/train_binary_masks/5086.png\")\n",
    "\n",
    "plt.imshow(img_temp);plt.imshow(msk_temp, alpha=0.3)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f74526082e8>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "rle_temp = rle_encode(cv2.imread(total_msk_paths[1],0))\n",
    "plt.imshow(rle_decode(rle_temp, (3000,3000)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# DELETE FILES WHICH ARE NOT LUNGS IMAGES\n",
    "import pandas as pd\n",
    "import os\n",
    "\n",
    "df = pd.read_csv(\"/home/lakshita/somusan/hubmap_kaggle/nbs/aug_lung_data/only_lung.csv\")\n",
    "old_df = pd.read_csv(\"/home/lakshita/somusan/hubmap_kaggle/nbs/aug_lung_data/train.csv\")\n",
    "\n",
    "DIR = \"/home/lakshita/somusan/hubmap_kaggle/nbs/aug_lung_data/hubmap-22-aug-pixel-size\" # where all the images are\n",
    "\n",
    "ids_tobe_deleted = [i for i in old_df['id'].to_list() if i not in df['id'].to_list()]\n",
    "files_tobe_deleted = [DIR+'/'+str(i)+\".png\" for i in ids_tobe_deleted]\n",
    "\n",
    "for file in files_tobe_deleted:\n",
    "    if os.path.exists(file):\n",
    "        os.remove(file) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# DELETE FILES WHICH ARE NOT LUNGS MASKS\n",
    "df = pd.read_csv(\"/home/lakshita/somusan/hubmap_kaggle/nbs/aug_lung_data/only_lung.csv\")\n",
    "old_df = pd.read_csv(\"/home/lakshita/somusan/hubmap_kaggle/nbs/aug_lung_data/train.csv\")\n",
    "\n",
    "DIR = \"/home/lakshita/somusan/hubmap_kaggle/nbs/aug_lung_data/train_binary_masks\"\n",
    "\n",
    "ids_tobe_deleted = [i for i in old_df['id'].to_list() if i not in df['id'].to_list()]\n",
    "files_tobe_deleted = [DIR+'/'+str(i)+\".png\" for i in ids_tobe_deleted]\n",
    "\n",
    "for file in files_tobe_deleted:\n",
    "    if os.path.exists(file):\n",
    "        os.remove(file) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "79"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# len(os.listdir(\"/home/lakshita/somusan/hubmap_kaggle/nbs/aug_lung_data/lung_images_aug_org\")) #79\n",
    "# df.__len__()# 79"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Extra part:\n",
    "- this is where I test w/ the data loader if the overlay works"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(os.listdir(\"/home/lakshita/somusan/hubmap_kaggle/nbs/aug_lung_data/mask\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# cv2.imwrite('demo_img.png', img_)\n",
    "# cv2.imwrite('demo_mask.png', mask_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "img = cv2.cvtColor(cv2.imread(\"/home/lakshita/somusan/hubmap_kaggle/nbs/aug_lung_data/image/15329.png\"), cv2.COLOR_BGR2RGB)\n",
    "plt.figure(figsize=(14,16))\n",
    "plt.imshow(img);plt.imshow(cv2.imread('/home/lakshita/somusan/hubmap_kaggle/nbs/aug_lung_data/mask/15329.png',0), alpha= 0.4)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "4 images[batch size] for bubble aug took 3min\n",
    "4 images[batch size] for stain aug took 3min\n",
    "4 images[batch size] for sectioning aug took 9 sec\n",
    "\n",
    "with data loader it works like a charm, that means it also works w/o that\n",
    "Net save them and run that effnet.\n",
    "\"\"\"\n",
    "items = next(iter(train_loader))\n",
    "imgs = items[\"image\"]\n",
    "mask = items[\"mask\"]\n",
    "\n",
    "imgs.shape, mask.shape "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "imgs = items[\"image\"]\n",
    "msks = items[\"mask\"]\n",
    "print(imgs.size(), msks.size())\n",
    "\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "def plot_batch(imgs, msks, size=3):\n",
    "    for idx in range(size):\n",
    "        plt.figure(figsize=(4*3, 5))\n",
    "\n",
    "        print(\"debug plot batch img \",imgs[idx].shape)\n",
    "        plt.subplot(1, 3, 1); plt.imshow(imgs[idx])\n",
    "        plt.title('image', fontsize=15)\n",
    "        plt.axis('OFF')\n",
    "        print(\"debug plot batch \",msks[idx].shape)\n",
    "        plt.subplot(1, 3, 2); plt.imshow(msks[idx])\n",
    "        plt.title('mask', fontsize=15)\n",
    "        plt.axis('OFF')\n",
    "            \n",
    "        plt.subplot(1, 3, 3); plt.imshow(imgs[idx]); plt.imshow(msks[idx], alpha=0.3)\n",
    "        plt.title('overlay', fontsize=15)\n",
    "        plt.axis('OFF')\n",
    "        \n",
    "        plt.tight_layout()\n",
    "        plt.show()\n",
    "\n",
    "plot_batch(imgs, msks, size=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.0 ('.venv': venv)",
   "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.7.0"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "21a2a557654fc1676068684031cf9bb9dfda94e124d3623f4e9c9ed764d794ac"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}