00_A_DL_Image_Patch_generation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    " PATCH GENERATION HELPER FUNCTIONS\n",
    " ---------------------------------\n",
    " by Luis R Soenksen\n",
    " Last Update: 2017/04/23\n",
    " Adapted from David Warde-Farley's code on image patch generation https://gist.github.com/dwf/366247/forks\n",
    "\"\"\"\n",
    "\n",
    "import os\n",
    "import cv2\n",
    "import numpy as np\n",
    "import scipy.ndimage as ndimage\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Helper Function definitions\n",
    "def frac_eq_to(image, value=0):\n",
    "    \"\"\"\n",
    "    Confirm valid dimensions of cropped fraction\n",
    "    \"\"\"\n",
    "    return (image == value).sum() / float(np.prod(image.shape))\n",
    "\n",
    "def extract_patches(image, patchshape, overlap_allowed=0.5, cropvalue=None,\n",
    "                    crop_fraction_allowed=0.1):\n",
    "    \"\"\"\n",
    "    Given an image, extract patches of a given shape with a certain\n",
    "    amount of allowed overlap between patches, using a heuristic to\n",
    "    ensure maximum coverage.\n",
    "\n",
    "    If cropvalue is specified, it is treated as a flag denoting a pixel\n",
    "    that has been cropped. Patch will be rejected if it has more than\n",
    "    crop_fraction_allowed * prod(patchshape) pixels equal to cropvalue.\n",
    "    Likewise, patches will be rejected for having more overlap_allowed\n",
    "    fraction of their pixels contained in a patch already selected.\n",
    "    \"\"\"\n",
    "    jump_cols = int(patchshape[1] * overlap_allowed)\n",
    "    jump_rows = int(patchshape[0] * overlap_allowed)\n",
    "    \n",
    "    # Restrict ourselves to the rectangle containing non-cropped pixels\n",
    "    if cropvalue is not None:\n",
    "        rows, cols = np.where(image != cropvalue)\n",
    "        rows.sort(); cols.sort()\n",
    "        active =  image[rows[0]:rows[-1], cols[0]:cols[-1]]\n",
    "    else:\n",
    "        active = image\n",
    "\n",
    "    rowstart = 0; colstart = 0\n",
    "\n",
    "    # Array tracking where we've already taken patches.\n",
    "    covered = np.zeros(active.shape, dtype=bool)\n",
    "    patches = []\n",
    "\n",
    "    while rowstart < active.shape[0] - patchshape[0]:\n",
    "        # Record whether or not e've found a patch in this row, \n",
    "        # so we know whether to skip ahead.\n",
    "        got_a_patch_this_row = False\n",
    "        colstart = 0\n",
    "        while colstart < active.shape[1] - patchshape[1]:\n",
    "            # Slice tuple indexing the region of our proposed patch\n",
    "            region = (slice(rowstart, rowstart + patchshape[0]),\n",
    "                      slice(colstart, colstart + patchshape[1]))\n",
    "            \n",
    "            # The actual pixels in that region.\n",
    "            patch = active[region]\n",
    "\n",
    "            # The current mask value for that region.\n",
    "            cover_p = covered[region]\n",
    "            if cropvalue is None or \\\n",
    "               frac_eq_to(patch, cropvalue) <= crop_fraction_allowed and \\\n",
    "               frac_eq_to(cover_p, True) <= overlap_allowed:\n",
    "                # Accept the patch.\n",
    "                patches.append(patch)\n",
    "                \n",
    "                # Mask the area.\n",
    "                covered[region] = True\n",
    "                \n",
    "                # Jump ahead in the x direction.\n",
    "                colstart += jump_cols\n",
    "                got_a_patch_this_row = True\n",
    "                #print \"Got a patch at %d, %d\" % (rowstart, colstart)\n",
    "            else:\n",
    "                # Otherwise, shift window across by one pixel.\n",
    "                colstart += 1\n",
    "\n",
    "        if got_a_patch_this_row:\n",
    "            # Jump ahead in the y direction.\n",
    "            rowstart += jump_rows\n",
    "        else:\n",
    "            # Otherwise, shift the window down by one pixel.\n",
    "            rowstart += 1\n",
    "\n",
    "    # Return a 3D array of the patches with the patch index as the first\n",
    "    # dimension (so that patch pixels stay contiguous in memory, in a \n",
    "    # C-ordered array).\n",
    "    return np.concatenate([pat[np.newaxis, ...] for pat in patches], axis=0)\n",
    "\n",
    "def plot_patches(patches, fignum=None, low=0, high=0):\n",
    "    \"\"\"\n",
    "    Given a stack of 2D patches indexed by the first dimension, plot the\n",
    "    patches in subplots. \n",
    "\n",
    "    'low' and 'high' are optional arguments to control which patches\n",
    "    actually get plotted. 'fignum' chooses the figure to plot in.\n",
    "    \"\"\"\n",
    "    try:\n",
    "        istate = plt.isinteractive()\n",
    "        plt.ioff()\n",
    "        if fignum is None:\n",
    "            fig = plt.gcf()\n",
    "        else:\n",
    "            fig = plt.figure(fignum)\n",
    "        if high == 0:\n",
    "            high = len(patches)\n",
    "        pmin, pmax = patches.min(), patches.max()\n",
    "        dims = np.ceil(np.sqrt(high - low))\n",
    "        for idx in range(high - low):\n",
    "            spl = plt.subplot(dims, dims, idx + 1)\n",
    "            ax = plt.axis('off')\n",
    "            im = plt.imshow(patches[idx], cmap=matplotlib.cm.gray)\n",
    "            cl = plt.clim(pmin, pmax)\n",
    "        plt.show()\n",
    "    finally:\n",
    "        plt.interactive(istate)\n",
    "\n",
    "def filter_patches(patches, min_mean=0.0, min_std=0.0):\n",
    "    \"\"\"\n",
    "    Filter patches by some criterion on their mean and variance.\n",
    "    \n",
    "    Takes patches, a 3-dimensional stack of image patches (where\n",
    "    the first dimension indexes the patch), and a minimum\n",
    "    mean and standard deviation. Returns a stack of all the \n",
    "    patches that satisfy both of these criteria.\n",
    "    \"\"\"\n",
    "    patchdim = np.prod(patches.shape[1:])\n",
    "    patchvectors = patches.reshape(patches.shape[0], patchdim)\n",
    "    means = patchvectors.mean(axis=1)\n",
    "    stdevs = patchvectors.std(axis=1)\n",
    "    indices = (means > min_mean) & (stdevs > min_std)\n",
    "    return patches[indices]\n",
    "\n",
    "def extract_patches_from_dir(directory, patchsize, \n",
    "                             smoothing=None, overlap_allowed=0.5,\n",
    "                             cropvalue=None, crop_fraction_allowed=0.1,\n",
    "                             min_mean=0, min_std=0):\n",
    "    \"\"\"\n",
    "    Extract patches from an entire directory of images.\n",
    "    \n",
    "    If `smoothing` is not None, it is used as the standard deviation of a\n",
    "    Gaussian filter applied to the image before extracting patches.\n",
    "    \n",
    "    `patchsize`, `overlap_allowed`, `cropvalue` and `crop_fraction_allowed`\n",
    "    are passed along to `extract_patches()`. `min_mean` and `min_std` are\n",
    "    passed along to `filter_patches()`.\n",
    "    \"\"\"\n",
    "    output = {}\n",
    "    for fname in os.listdir(directory):\n",
    "        if fname[-4:] == '.png':\n",
    "            outname = fname.replace('.','_').replace('-','_')\n",
    "            assert outname not in output\n",
    "            image = cv2.imread(os.path.join(directory, fname))\n",
    "            \n",
    "            if smoothing is not None:\n",
    "                image = ndimage.gaussian_filter(image, smoothing)\n",
    "            # Extract patches from the image.\n",
    "            output[outname] = extract_patches(image, patchsize,\n",
    "                                              overlap_allowed,\n",
    "                                              cropvalue, crop_fraction_allowed)\n",
    "\n",
    "            # Filter the patches that don't meet our standards.\n",
    "            output[outname] = filter_patches(output[outname], min_std=min_std,\n",
    "                                             min_mean=min_mean)\n",
    "    return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Patch generation from big image\n",
    "image_directory = 'images_to_patch'\n",
    "patchshape=[100,100]\n",
    "\n",
    "ep_directory = (image_directory + '/EP')\n",
    "if not os.path.exists(ep_directory):\n",
    "    os.makedirs(ep_directory)\n",
    "\n",
    "dir_patches = extract_patches_from_dir(image_directory, patchshape, smoothing=None, \n",
    "                               overlap_allowed=0.5,cropvalue=None, crop_fraction_allowed=0.1,\n",
    "                               min_mean=0, min_std=0)\n",
    "\n",
    "for key, value in dir_patches.items():\n",
    "    image_name = key\n",
    "    patches = value\n",
    "    \n",
    "    print(\"Patches of image: \" + image_name)\n",
    "    plot_patches(patches)\n",
    "    \n",
    "    for n_patch in range(patches.shape[0]):\n",
    "        cv2.imwrite(ep_directory + \"/\" + image_name + \"_\" + str(n_patch) + \".png\",patches[n_patch,:,:,:])\n",
    "    "
   ]
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}