crop_cbis_images_100.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Save full images as jpgs with 3 channels:\n",
    " 1. actual image\n",
    " 2. mask\n",
    " 3. zeros, just here so images can be saved as jpegs\n",
    " \n",
    "Images are a minimum of 1280 pixels wide, a portion of the black background is trimmed to keep the images mostly usable. The height is unaltered. No zooming is done to the images at all.\n",
    "\n",
    "These images will be read off of disk and randomly cropped in TensorFlow to provide more training data in files of reasonable sizes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import PIL\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "import os\n",
    "import random\n",
    "import glob\n",
    "import shutil\n",
    "import re\n",
    "from scipy.misc import imresize, toimage\n",
    "from mammo_utils import create_mask, half_image, get_fuzzy_offset, progress, clean_name, random_flip_image\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def create_cbis_slices(mask_dir,image_dir,  name, debug=True):\n",
    "    # initialize return variables\n",
    "    image_list = []\n",
    "    pixel_means_list = []\n",
    "    \n",
    "    # get list of files in the directory\n",
    "    image_files = os.listdir(image_dir)\n",
    "    counter = 0\n",
    "    \n",
    "    # display the progress bar\n",
    "    if debug is None:\n",
    "        progress(counter, len(image_files), 'WORKING')\n",
    "       \n",
    "    # make sure the destination directory exists\n",
    "    if not os.path.exists(os.path.join(\"data\", name)):\n",
    "        os.mkdir(os.path.join(\"data\", name))\n",
    "    \n",
    "    # loop through the masks\n",
    "    for cur_image in image_files:\n",
    "        \n",
    "        # update the progress bar\n",
    "        counter += 1\n",
    "        if debug is None:\n",
    "            progress(counter, len(image_files), cur_image)\n",
    "            \n",
    "        # get the image name\n",
    "        base_image_file = clean_name(cur_image)\n",
    "        \n",
    "        full_image = PIL.Image.open(os.path.join(image_dir, cur_image))\n",
    "        full_image_arr = np.array(full_image)[:,:,0]\n",
    "        \n",
    "        # find which masks match, there may be more than one\n",
    "        matching_masks = glob.glob(os.path.join(mask_dir, base_image_file + \"*\" + \".jpg\"))\n",
    "        \n",
    "        # create a blank mask same size as image\n",
    "        mask_image = np.zeros_like(full_image_arr)\n",
    "        \n",
    "        # loop through the masks\n",
    "        for mask in matching_masks:\n",
    "            # load the mask\n",
    "            cur_mask = np.array(PIL.Image.open(os.path.join(mask_dir, mask)))[:,:,0]\n",
    "            \n",
    "            # if the mask is the right shape\n",
    "            if mask_image.shape == cur_mask.shape:\n",
    "                # update our global mask accordingly\n",
    "                mask_image[cur_mask > 0] = 1\n",
    "        \n",
    "        # try to remove some of the black background from the image\n",
    "        mostly_black_cols = np.sum(full_image_arr < 10, axis=0)\n",
    "        image_mostly_black = mostly_black_cols > (full_image_arr.shape[0] * 0.90)\n",
    "        \n",
    "        # determine which way the image is oriented\n",
    "        first_black_col = np.argmax(image_mostly_black)\n",
    "        \n",
    "        # if there are a substantial number of mostly black columns then we will try to trim them\n",
    "        if np.sum(image_mostly_black) > (full_image_arr.shape[1] * 0.15):\n",
    "            # if the first black col is not at the beginning we trim from the right\n",
    "            if first_black_col > 500:\n",
    "                # add some padding\n",
    "                first_black_col += 300\n",
    "                \n",
    "                # make sure the image is at least 1280 pixels wide\n",
    "                first_black_col = np.max([first_black_col, 1280])\n",
    "                \n",
    "                # include up to the first black col\n",
    "                full_image_arr = full_image_arr[:,:first_black_col]\n",
    "                mask_image = mask_image[:,:first_black_col]\n",
    "\n",
    "            # else we need to reverse the array and trim from the left\n",
    "            else:\n",
    "                first_black_col = len(image_mostly_black) - np.argmax(np.flip(image_mostly_black, axis=0))\n",
    "\n",
    "                # add some padding\n",
    "                first_black_col -= 300\n",
    "                \n",
    "                # make sure the image is at least 1280 pixels wide\n",
    "                first_black_col = np.min([first_black_col, full_image_arr.shape[1] - 1280])\n",
    "                \n",
    "                # trim from the right\n",
    "                full_image_arr = full_image_arr[:,first_black_col:]\n",
    "                mask_image = mask_image[:,first_black_col:]\n",
    "            \n",
    "        # set white pixels to 1 instead of 255\n",
    "#         mask_image[mask_image > 0] = 1\n",
    "        \n",
    "        # alert if image is way too small\n",
    "        if full_image_arr.shape[1] < 1000:\n",
    "            print(\"Image too small!\", cur_image)\n",
    "            print(mask, full_image_arr.shape)\n",
    "        \n",
    "        # make sure the mask and image are the same size\n",
    "        if full_image_arr.shape != mask_image.shape:\n",
    "            print(\"Shapes don't match\", cur_image)\n",
    "            continue\n",
    "        else:\n",
    "            # add the mean of the mask to the mean list\n",
    "            pixel_means_list.append(np.mean(mask_image))\n",
    "            \n",
    "            # save the image\n",
    "            image = np.dstack((full_image_arr, mask_image, np.zeros_like(full_image_arr))).astype(np.uint8)\n",
    "            \n",
    "            im = PIL.Image.fromarray(image)\n",
    "            im.save(os.path.join(\"data\", name, base_image_file + \"_\" + str(counter) + \".png\"))\n",
    "            \n",
    "#         if counter > 10:\n",
    "#             break\n",
    "        \n",
    "    # return the data\n",
    "    return pixel_means_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def plot_random_samples(images, N=20):\n",
    "    idxs = random.sample(range(len(images)), k=N)\n",
    "\n",
    "    for idx in idxs:\n",
    "        f, ax = plt.subplots(1, 2, figsize=(8, 4))\n",
    "        ax[0].imshow(images[idx][:,:,0])\n",
    "        ax[0].set_title(\"Image\")\n",
    "        ax[1].imshow(images[idx][:,:,1])\n",
    "        ax[1].set_title(\"Label\")\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## All Images At Once"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[============================================================] 100.0% ...P_02584_LEFT_MLO_FULL.jpggg\r"
     ]
    }
   ],
   "source": [
    "# load the labels\n",
    "test_labels = pd.read_pickle(os.path.join(\"data\", \"test_labels.pkl\"))\n",
    "test_labels['IMAGE_NAME2'] = test_labels.index\n",
    "test_labels = test_labels.drop_duplicates(['IMAGE_NAME2'])\n",
    "\n",
    "## use a copy on the local drive to make testing faster\n",
    "mask_dir = \"C:\\\\Users\\\\eric\\\\Documents\\\\Courses\\\\Applied ML 2\\\\mammography\\\\data\\\\cbis-ddsm\\\\All Masks\"\n",
    "image_dir = \"C:\\\\Users\\\\eric\\\\Documents\\\\Courses\\\\Applied ML 2\\\\mammography\\\\data\\\\cbis-ddsm\\\\All Images\"\n",
    "\n",
    "mu = create_cbis_slices(mask_dir, image_dir, name=\"mask_images\", debug=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1910483cfd0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x19100980b38>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x19164a36d30>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "full_image_arr = PIL.Image.open(\"C:\\\\Users\\\\eric\\\\Documents\\\\Courses\\\\Applied ML 2\\\\mammography\\\\data\\\\mask_images\\\\P_00009_RIGHT_CC_14.png\")\n",
    "full_image_arr = np.array(full_image_arr)\n",
    "\n",
    "plt.imshow(full_image_arr[:,:,0])\n",
    "plt.show()\n",
    "\n",
    "plt.imshow(full_image_arr[:,:,1])\n",
    "plt.show()\n",
    "\n",
    "plt.imshow(full_image_arr[:,:,2])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pixel mean: 0.01393677365042314\n"
     ]
    }
   ],
   "source": [
    "print(\"Pixel mean:\",np.mean(mu))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Move Files to Proper Directories"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "test_images = os.listdir(\"C:\\\\Users\\\\eric\\\\Documents\\\\Courses\\\\Applied ML 2\\\\mammography\\\\data\\\\cbis-ddsm\\\\Test Images\")\n",
    "\n",
    "for image in test_images:\n",
    "    base_image_name = clean_name(image)\n",
    "    \n",
    "    matching_images = glob.glob(\"C:\\\\Users\\\\eric\\\\Documents\\\\Courses\\\\Applied ML 2\\\\mammography\\\\data\\\\train_images\\\\\" + base_image_name + \"*.png\")\n",
    "    if len(matching_images):\n",
    "        for test_image in matching_images:\n",
    "            file_name = test_image.split(\"\\\\\")[-1]\n",
    "            print(file_name)\n",
    "#             os.rename(test_image, \"C:\\\\Users\\\\eric\\\\Documents\\\\Courses\\\\Applied ML 2\\\\mammography\\\\data\\\\test_images\\\\\" + file_name)"
   ]
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}