05_imageTools.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%nbdev_hide\n",
    "# IN_COLAB = 'google.colab' in str(get_ipython())\n",
    "# if IN_COLAB:\n",
    "#   !pip install git+https://github.com/pete88b/nbdev_colab_helper.git\n",
    "#   from nbdev_colab_helper.core import *\n",
    "#   project_name = 'syntheticReplica'\n",
    "#   init_notebook(project_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cells will be exported to syntheticReplica.imageTools,\n",
      "unless a different module is specified after an export flag: `%nbdev_export special.module`\n"
     ]
    }
   ],
   "source": [
    "%nbdev_hide\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "from nbdev import *\n",
    "%nbdev_default_export imageTools\n",
    "\n",
    "from nbdev.showdoc import *\n",
    "from fastcore.nb_imports import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%nbdev_export\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "from shapely.geometry import Polygon, MultiPolygon\n",
    "from PIL import Image\n",
    "from dataclasses import dataclass, field\n",
    "from syntheticReplica.display import *\n",
    "from syntheticReplica.dirView import *\n",
    "from skimage import measure\n",
    "from pathlib import Path\n",
    "\n",
    "\n",
    "# Display output mask\n",
    "def viewMask(path_image:Path, path_mask:Path, new_mask) -> None:\n",
    "    fname = path_image.stem + \".png\"\n",
    "    mask_path = path_mask.joinpath(fname)\n",
    "    new_mask.save(mask_path)\n",
    "\n",
    "# Find center of image(i.e. zone of inhibition)\n",
    "def findCenter(path_image:Path, coord:tuple) -> int:\n",
    "    fore_img_size = imageSize(path_image)\n",
    "    center_x = coord[0] + fore_img_size[0]//2\n",
    "    center_y = coord[1] + fore_img_size[1]//2\n",
    "    return center_x, center_y\n",
    "\n",
    "# Find coordinate of disk on top of zone of inhibition\n",
    "def findDiskCoord(path_image:Path, center_x:int, center_y:int) -> int:\n",
    "    fore_img_size = imageSize(path_image)\n",
    "    coord_x = center_x - fore_img_size[0]//2\n",
    "    coord_y = center_y - fore_img_size[1]//2\n",
    "    return coord_x, coord_y\n",
    "\n",
    "# Preprocess image for composite\n",
    "def preComposite(path_image:Path, coord:tuple, img_size:tuple, back:Path, index_name:str):\n",
    "    fore_img = Image.open(path_image)\n",
    "    fore_img_size = imageSize(path_image)\n",
    "    new_fore = Image.new(\"RGBA\", img_size , color=(0, 0, 0, 0))\n",
    "    new_fore.paste(fore_img, tuple(coord))\n",
    "    new_mask = Image.new(\"L\", img_size, color=0)\n",
    "    # Get the alpha channel image.\n",
    "    fore_img_mask = fore_img.getchannel(3)\n",
    "    # Paste the foreground alpha into the new mask.\n",
    "    new_mask.paste(fore_img_mask, tuple(coord))\n",
    "    #viewMask(image, mask_path, new_mask)\n",
    "    background = Image.open(back)\n",
    "    return new_fore, background, new_mask, index_name\n",
    "\n",
    "# Create composite image\n",
    "def compositeBuild(new_fore, back, new_mask, fname:str, train_path:Path):\n",
    "    # Composite image is blended from a foreground, background and mask, all of the same size.\n",
    "    composite_img = Image.composite(new_fore, back, new_mask)\n",
    "    # Save the new composited image.\n",
    "    path_composite = train_path.joinpath(fname)\n",
    "    composite_img.save(path_composite)\n",
    "    return new_mask\n",
    "\n",
    "# Find foreground image contour\n",
    "def findContours(new_mask, coord):\n",
    "    contours = measure.find_contours(new_mask, 0.8)\n",
    "    new_contours = []\n",
    "    for cont in contours:\n",
    "        for i in range(len(contours[0])):\n",
    "            _contours = (cont[i][1], cont[i][0])\n",
    "            new_contours.append(_contours)\n",
    "\n",
    "    new_contours_array = np.array(new_contours)\n",
    "    re = new_contours_array.shape[0]\n",
    "    new_contours_array = new_contours_array.reshape(-1, re, 2)\n",
    "    return new_contours_array, new_contours_array.size\n",
    "\n",
    "# Convert contour to segmentation\n",
    "def contours2Segmentations(contours_array, tolerance:int=1.0, preserve_topology:bool=False):\n",
    "    segmentations = []\n",
    "    polygons = []\n",
    "\n",
    "    for contour in contours_array:\n",
    "        poly = Polygon(contour)\n",
    "        poly = poly.simplify(tolerance, preserve_topology=preserve_topology)\n",
    "        polygons.append(poly)\n",
    "        seg = np.array(poly.exterior.coords).ravel().tolist()\n",
    "        segmentations.append(seg)\n",
    "    return polygons, segmentations\n",
    "\n",
    "# Convert segmentation to bounding box area\n",
    "def seg2BBoxArea(polygons):\n",
    "    multi_poly = MultiPolygon(polygons)\n",
    "    x, y, max_x, max_y = multi_poly.bounds\n",
    "    width = max_x - x\n",
    "    height = max_y - y\n",
    "    bbox = [x, y, width, height]\n",
    "    area = multi_poly.area\n",
    "    return [bbox, area]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%nbdev_export\n",
    "def findCoord(images:list, coord:tuple) -> tuple:\n",
    "    center_x, center_y = findCenter(images[0], coord)\n",
    "    disk_x, disk_y = findDiskCoord(images[1], center_x, center_y)\n",
    "    return (disk_x, disk_y)\n",
    "\n",
    "def compositeImage(path_image:Path, coord:tuple, img_size:tuple, back:Path, fname_train:str, train_path:Path, index_name:str):\n",
    "    new_fore, background, new_mask, index_name = preComposite(path_image, coord, img_size, back, index_name)\n",
    "    mask = compositeBuild(new_fore, background, new_mask, fname_train, train_path)\n",
    "    return mask, index_name\n",
    "\n",
    "def imgCompSegBbox(path_image:Path, coord:tuple, img_size:tuple, back:Path, fname_train:str, train_path:Path, index_name:str):\n",
    "    mask, index_name = compositeImage(path_image, coord, img_size, back, fname_train, train_path, index_name)\n",
    "    contours_array, countours_size = findContours(mask, coord)\n",
    "    polygons, segmentation = contours2Segmentations(contours_array, tolerance=1.0, preserve_topology=False)\n",
    "    bbox, area = seg2BBoxArea(polygons)\n",
    "    return bbox, area, segmentation, index_name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converted 05_imageTools.ipynb.\n"
     ]
    }
   ],
   "source": [
    "%nbdev_hide\n",
    "# Convert to module\n",
    "from nbdev.export import notebook2script\n",
    "notebook2script(\"05_imageTools.ipynb\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ""
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}