11_rotate_tissue_sections.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Margin Clearance\n",
    "\n",
    "This is example of how to extract tumour margins from the segmentations. It is not an automated scripted for all images, but outputs the margins from the 10x test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.patches import Rectangle as BoundingBox\n",
    "\n",
    "import skimage.io as io\n",
    "from skimage.measure import label, regionprops\n",
    "from skimage.morphology import closing, square, disk\n",
    "from skimage.morphology import binary_closing\n",
    "from skimage.transform import rotate\n",
    "from skimage.filters import median\n",
    "\n",
    "from sklearn.linear_model import LinearRegression\n",
    "\n",
    "from scipy.misc import imrotate\n",
    "\n",
    "\n",
    "import keras\n",
    "import keras.backend as K\n",
    "from keras.layers import Input, Conv2D, GlobalMaxPool2D, Dense, Flatten\n",
    "from keras.models import Model\n",
    "from keras.optimizers import Adam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create color palette\n",
    "color_dict = {\n",
    "    \"EPI\":  [73, 0, 106],\n",
    "    \"GLD\":  [108, 0, 115],\n",
    "    \"INF\":  [145, 1, 122],\n",
    "    \"RET\":  [181, 9, 130],\n",
    "    \"FOL\":  [216, 47, 148],\n",
    "    \"PAP\":  [236, 85, 157],\n",
    "    \"HYP\":  [254, 246, 242],\n",
    "    \"KER\":  [248, 123, 168],\n",
    "    \"BKG\":  [0, 0, 0],\n",
    "    \"BCC\":  [127, 255, 255],\n",
    "    \"SCC\":  [127, 255, 142],\n",
    "    \"IEC\":  [255, 127, 127]\n",
    "}\n",
    "\n",
    "LUT = {\n",
    "      0 : \"EPI\",\n",
    "      1 : \"GLD\",\n",
    "      2 : \"INF\",\n",
    "      3 : \"RET\",\n",
    "      4 : \"FOL\",\n",
    "      5 : \"PAP\",\n",
    "      6 : \"HYP\",\n",
    "      7 : \"KER\",\n",
    "      8 : \"BKG\",\n",
    "      9 : \"BCC\",\n",
    "      10 : \"SCC\",\n",
    "      11: \"IEC\"\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def radians2degress(radians):\n",
    "    return radians * 180/np.pi\n",
    "\n",
    "def degrees2radians(degrees):\n",
    "    return  degrees * (np.pi / 180)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convert_RGB_to_8bit(image):\n",
    "    \"\"\" returns the 8 bit encoding of the image based on the LUT and color_dict order\"\"\"\n",
    "    segmentation_8bit = np.zeros((image.shape[0], image.shape[1]), dtype=\"uint8\")\n",
    "    for i in range(12):\n",
    "        segmentation_8bit[np.all(image == color_dict[LUT[i]], axis=-1)] = i\n",
    "    return segmentation_8bit\n",
    "\n",
    "def convert_8bit_to_RGB(image):\n",
    "    \"\"\" returns the rgb encoding of the 8-bit image based on the LUT and color_dict order\"\"\"\n",
    "    segmentation_rgb = np.zeros((image.shape[0], image.shape[1], 3), dtype=\"uint8\")\n",
    "    for i in range(12):\n",
    "        segmentation_rgb[image == i] = color_dict[LUT[i]]\n",
    "    return segmentation_rgb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pad_image(image, value):\n",
    "    \"\"\"\n",
    "    Pads the image to make a square the size of the hypotenuse\n",
    "    \"\"\"\n",
    "    # Find largest axis\n",
    "    rows, cols = image.shape[0], image.shape[1]\n",
    "    \n",
    "    # Find hypotenuse\n",
    "    hyp = int(np.sqrt(rows**2 + cols**2))\n",
    "    \n",
    "    # Calculate size to pad\n",
    "    pad_width = [[],[],(0, 0)]\n",
    "    diff = hyp - rows\n",
    "    extra = diff % 2\n",
    "    size = diff // 2\n",
    "    pad_width[0] = [size, size+extra]\n",
    "    \n",
    "    \n",
    "    diff = hyp - cols\n",
    "    extra = diff % 2\n",
    "    size = diff // 2\n",
    "    pad_width[1] = [size, size+extra]\n",
    "\n",
    "    return np.pad(image, pad_width, mode=\"constant\", constant_values=(value, value))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_orientation(segmantation_mask):\n",
    "    # Get EPI mask\n",
    "    epi = np.all(segmantation_mask == color_dict[\"PAP\"], axis=-1).astype(\"int\")\n",
    "\n",
    "    # Get points of EPI\n",
    "    points = np.where(epi)\n",
    "\n",
    "    # Reshape coords\n",
    "    X = points[0].reshape(-1, 1)\n",
    "    y = points[1].reshape(-1, 1)\n",
    "\n",
    "    # Fit line\n",
    "    reg = LinearRegression().fit(X, y)\n",
    "\n",
    "    # Get predict points\n",
    "    y1, x1 = np.min(X), np.int(reg.predict(np.array([[np.min(X)]]))[0, 0])\n",
    "    y2, x2 = np.max(X), np.int(reg.predict(np.array([[np.max(X)]]))[0, 0])\n",
    "    \n",
    "    # Get lengths of triangle\n",
    "    opp = y1 - y2\n",
    "    adj = x2 - x1\n",
    "\n",
    "    # Set base angle based on line lengths\n",
    "    base = 0\n",
    "    if opp < 0 and adj < 0:\n",
    "        base = 180\n",
    "    \n",
    "    # Calculate angle change\n",
    "    rads = np.arctan(opp / adj)\n",
    "    theta = degrees_to_rotate = base - radians2degress(rads)\n",
    "    radians = degrees2radians(degrees_to_rotate)\n",
    "    \n",
    "    # Check if orientation was already upwards\n",
    "#     whole  = np.all(segmantation_mask != color_dict[\"BKG\"], axis=-1).astype(\"int\")\n",
    "#     x_centroid, y_centroid = regionprops(whole)[0].centroid\n",
    "#     y_center = opp / 2\n",
    "#     if y_centroid > y_center: # Already facing up\n",
    "#         theta += 180\n",
    "#         radians == np.pi\n",
    "    \n",
    "    return theta, radians, (x1, y1), (x2, y2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rotate_image(image, theta, fill=255, median_filter=False):\n",
    "    \"\"\"\n",
    "    Rotates and resizes the image based on theta (in degrees). Value\n",
    "    is a greyscale color between 0-1.\n",
    "    \n",
    "    To Implement:\n",
    "        resize by padding the image to the largest axis, that way it won't have to rescale\n",
    "        \n",
    "    \"\"\"\n",
    "    temp = pad_image(image, fill)\n",
    "    # Convert to 8bit to apply median filters and then back again\n",
    "    if median_filter:\n",
    "        temp = convert_8bit_to_RGB(median(convert_RGB_to_8bit(temp), disk(6)))\n",
    "    temp = rotate(temp, theta, resize=False, cval=fill/255., order=0) # order = 'nearest neighbor'\n",
    "    return (temp*255.).astype(\"uint8\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_cancer_margins(rotated_segmentation):\n",
    "    \"\"\"\n",
    "    Finds the North, South, East and West extremities of the cancer classes.\n",
    "    \n",
    "    Returns the points as (x,y) in the order [N, S, E, W]\n",
    "    \"\"\"\n",
    "    # Get Cancer\n",
    "    cancer = np.logical_or(\n",
    "                        np.all(rot_segmentation == color_dict[\"BCC\"], axis=-1),\n",
    "                        np.logical_or(np.all(rot_segmentation == color_dict[\"SCC\"], axis=-1),\n",
    "                                           np.all(rot_segmentation == color_dict[\"IEC\"], axis=-1)\n",
    "                                     )\n",
    "                    ).astype(\"int\")\n",
    "    \n",
    "    # Measure region\n",
    "    region = regionprops(cancer)[0]\n",
    "\n",
    "    # Get bounding box coords\n",
    "    minr, minc, maxr, maxc = region.bbox\n",
    "\n",
    "    # Get coords for extremeties of cancer\n",
    "    yN, xN = minr, minc+np.median(np.where(region.convex_image[0, :]))\n",
    "    yS, xS = minr+(maxr-minr), minc+np.median(np.where(region.convex_image[-1, :]))\n",
    "    yE, xE = minr+np.median(np.where(region.convex_image[:, -1])), minc+(maxc-minc)\n",
    "    yW, xW = minr+np.median(np.where(region.convex_image[:, 0])), minc\n",
    "    \n",
    "    return (xN, yN), (xS, yS), (xE, yE), (xW, yW)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_tissue_margins(rotated_segmentation):\n",
    "    \"\"\"\n",
    "    Find the East and West extremities of the top tissue layers.\n",
    "    \n",
    "    Returns the points as (x, y) in the order [E, W]\n",
    "    \"\"\"\n",
    "    # Get Cancer\n",
    "    top = np.logical_or(\n",
    "                    np.all(rotated_segmentation == color_dict[\"EPI\"], axis=-1),\n",
    "                    np.all(rotated_segmentation == color_dict[\"PAP\"], axis=-1)\n",
    "                   ).astype(\"int\")\n",
    "    \n",
    "    # Measure region\n",
    "    region = regionprops(top)[0]\n",
    "\n",
    "    # Get bounding box coords\n",
    "    minr, minc, maxr, maxc = region.bbox\n",
    "\n",
    "    # Get coords for extremeties of tissue\n",
    "    yE_tissue, xE_tissue = minr+np.median(np.where(region.convex_image[:, -1])), minc+(maxc-minc)\n",
    "    yW_tissue, xW_tissue = minr+np.median(np.where(region.convex_image[:, 0])), minc\n",
    "\n",
    "    return (xE_tissue, yE_tissue), (xW_tissue, yW_tissue)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Directions stored as x, y\n",
    "directions_forward  = [[0, 1], [1, 1], [1, 0], [1, -1], [0, -1], [-1,-1], [-1,0], [-1, 1]]\n",
    "directions_backward = [[0, 1], [-1,1], [-1,0], [-1,-1], [0, -1], [1, -1], [1, 0], [ 1, 1]]\n",
    "                                    \n",
    "def inverse(direction):\n",
    "    x, y = direction\n",
    "    return [x*-1, y*-1]\n",
    "\n",
    "def nextPixel(state, sequence, binary_mask):\n",
    "    x,y,d = state\n",
    "    directions = sequence[d::] + sequence[0:d]\n",
    "    for i, nextdir in enumerate(directions):\n",
    "        # assume binary_mask[y, x] (rows, cols) is true if pixel x,y is foreground\n",
    "        if binary_mask[y+nextdir[1], x+nextdir[0]]:\n",
    "            break\n",
    "    # Find the position\n",
    "    inv = inverse(nextdir)\n",
    "    pos = sequence.index(inv)\n",
    "    # Start from the previous location + 1 (no immediate repeat)\n",
    "    d = (pos + 1) % 8\n",
    "    return([ x+nextdir[0], y+nextdir[1], d ])\n",
    "\n",
    "\n",
    "def exitCondition(state, color_mask, dist=20, show=False):\n",
    "    neighborhood = color_mask[state[1]-dist:state[1]+dist, state[0]-dist:state[0]+dist]\n",
    "    \n",
    "    if show:\n",
    "        fig2, ax2 = plt.subplots()\n",
    "        ax2.imshow(rot_segmentation[state[1]-dist:state[1]+dist, state[0]-dist:state[0]+dist])\n",
    "        fig.show()\n",
    "    \n",
    "    # Model input\n",
    "    X = neighborhood / 255.\n",
    "    p = model.predict(np.expand_dims(X, axis=0))[0] \n",
    "    if p > 0.9999:\n",
    "        print(p)\n",
    "        return True\n",
    "    \n",
    "    return False\n",
    "\n",
    "def get_crawl_start_position(rotated_RGB_segmentation):\n",
    "    \"\"\"\n",
    "    Returns the starting point (x, y) for crawl.\n",
    "    \"\"\"\n",
    "    # Get non-BKG mask\n",
    "    mask = np.all(rotated_RGB_segmentation != color_dict[\"BKG\"], axis=-1).astype(\"int\")\n",
    "    # Characterise and get centroid\n",
    "    region = regionprops(mask)[0]\n",
    "    x, y1 = region.centroid\n",
    "    # Get last position of true values\n",
    "    y2 = np.where(mask[:, int(x)])[0][-1]\n",
    "    \n",
    "    return (x, y2), mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_tissue_margin(rotated_segmentation, east=True):\n",
    "    \"\"\"\n",
    "    return (x, y) position of east/west tissue margin. East is \n",
    "    forward pass, west is backward.\n",
    "    \"\"\"\n",
    "    # Get starting position\n",
    "    (x, y), mask = get_crawl_start_position(rotated_segmentation)\n",
    "    # Set state - 1 for forward sequence : 0 for backward sequence\n",
    "    state = [int(x), int(y), 0]\n",
    "    \n",
    "    # Get 8-bit version\n",
    "    #color_mask = convert_RGB_to_8bit(rotated_segmentation)\n",
    "    color_mask = rotated_segmentation\n",
    "    \n",
    "    # Set direction\n",
    "    if east:\n",
    "        sequence = directions_forward\n",
    "    else:\n",
    "        sequence = directions_backward\n",
    "    \n",
    "    # Crawl!\n",
    "    count = 0\n",
    "    while count < 2e3: # Limit to 5K steps\n",
    "        state = nextPixel(state, sequence, mask)\n",
    "        count + 1\n",
    "        \n",
    "        if count % 20 == 0:\n",
    "            if exitCondition(state, color_mask, dist=20):\n",
    "                break\n",
    "        \n",
    "    return (state[0], state[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Run Code\n",
    "\n",
    "This is a demo of how to orient and measure the surgical margins"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "#seg_dir = \"/home/simon/Documents/PhD/Data/Histo_Segmentation/Datasets_n290/10x/Masks/\"\n",
    "seg_dir = \"/home/simon/Desktop/10x_Experiments_Over_Aug/ALL_IMAGES/\"\n",
    "image_dir = \"/home/simon/Documents/PhD/Data/Histo_Segmentation/Datasets_n290/10x/Images/\"\n",
    "out_dir = \"/home/simon/Desktop/Margins/\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "images = [\n",
    "\"IEC_45\",\n",
    "\"SCC_23\",\n",
    "\"SCC_32\",\n",
    "\"BCC_131\",\n",
    "\"BCC_135\",\n",
    "\"SCC_52\",\n",
    "\"SCC_20\",\n",
    "\"BCC_4\",\n",
    "\"SCC_9\",\n",
    "\"BCC_48\",\n",
    "\"BCC_80\",\n",
    "\"SCC_38\",\n",
    "\"BCC_95\",\n",
    "\"BCC_86\",\n",
    "\"BCC_133\",\n",
    "\"IEC_75\",\n",
    "\"BCC_51\",\n",
    "\"IEC_41\",\n",
    "\"BCC_90\",\n",
    "\"BCC_74\",\n",
    "\"BCC_22\",\n",
    "\"SCC_7\",\n",
    "\"SCC_24\",\n",
    "\"IEC_22\",\n",
    "\"IEC_23\",\n",
    "\"BCC_60\",\n",
    "\"BCC_61\",\n",
    "\"IEC_34\",\n",
    "\"IEC_35\",\n",
    "\"BCC_23\",\n",
    "\"BCC_24\"\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "ppmm = 0.00067\n",
    "green = (15/255., 1, 16/255.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 of 31 - BCC_80\n",
      "getting orientation...\n",
      "rotating...\n",
      "finding cancer margins...\n",
      "FAILED... list index out of range\n",
      "2 of 31 - SCC_38\n",
      "getting orientation...\n",
      "rotating...\n",
      "finding cancer margins...\n",
      "Finding East margin...\n",
      "[1.]\n",
      "Finding West margin...\n",
      "[1.]\n",
      "3 of 31 - BCC_95\n",
      "getting orientation...\n",
      "rotating...\n",
      "finding cancer margins...\n",
      "Finding East margin...\n",
      "[0.99992037]\n",
      "Finding West margin...\n",
      "[0.9999995]\n",
      "4 of 31 - BCC_86\n",
      "getting orientation...\n",
      "rotating...\n",
      "finding cancer margins...\n",
      "Finding East margin...\n",
      "[0.9999963]\n",
      "Finding West margin...\n",
      "[0.9999893]\n",
      "5 of 31 - BCC_133\n",
      "getting orientation...\n",
      "rotating...\n",
      "finding cancer margins...\n",
      "Finding East margin...\n",
      "[1.]\n",
      "Finding West margin...\n",
      "[0.9999999]\n",
      "6 of 31 - IEC_75\n",
      "getting orientation...\n",
      "rotating...\n",
      "finding cancer margins...\n",
      "Finding East margin...\n",
      "[0.99999785]\n",
      "Finding West margin...\n",
      "[0.9999182]\n",
      "7 of 31 - BCC_51\n",
      "getting orientation...\n",
      "rotating...\n",
      "finding cancer margins...\n",
      "Finding East margin...\n",
      "[0.99999976]\n",
      "Finding West margin...\n",
      "[0.9999951]\n",
      "8 of 31 - IEC_41\n",
      "getting orientation...\n",
      "rotating...\n",
      "finding cancer margins...\n",
      "Finding East margin...\n",
      "[0.9999999]\n",
      "Finding West margin...\n",
      "[0.9999999]\n",
      "9 of 31 - BCC_90\n",
      "getting orientation...\n",
      "rotating...\n",
      "finding cancer margins...\n",
      "Finding East margin...\n",
      "[0.9999783]\n",
      "Finding West margin...\n",
      "[0.99999976]\n",
      "10 of 31 - BCC_74\n",
      "getting orientation...\n",
      "rotating...\n",
      "finding cancer margins...\n",
      "Finding East margin...\n",
      "[1.]\n",
      "Finding West margin...\n",
      "[0.9999956]\n",
      "11 of 31 - BCC_22\n",
      "getting orientation...\n",
      "rotating...\n",
      "finding cancer margins...\n",
      "Finding East margin...\n",
      "[0.9999653]\n",
      "Finding West margin...\n",
      "[0.99994683]\n",
      "12 of 31 - SCC_7\n",
      "getting orientation...\n",
      "rotating...\n",
      "finding cancer margins...\n",
      "Finding East margin...\n",
      "[0.9999082]\n",
      "Finding West margin...\n",
      "[0.9999994]\n",
      "13 of 31 - SCC_24\n",
      "getting orientation...\n",
      "rotating...\n",
      "finding cancer margins...\n",
      "Finding East margin...\n",
      "[0.9999924]\n",
      "Finding West margin...\n",
      "[0.999984]\n",
      "14 of 31 - IEC_22\n",
      "getting orientation...\n",
      "rotating...\n",
      "finding cancer margins...\n",
      "Finding East margin...\n",
      "[0.9999497]\n",
      "Finding West margin...\n",
      "[0.9999995]\n",
      "15 of 31 - IEC_23\n",
      "getting orientation...\n",
      "rotating...\n",
      "finding cancer margins...\n",
      "Finding East margin...\n",
      "[0.99999356]\n",
      "Finding West margin...\n",
      "[0.99995065]\n",
      "16 of 31 - BCC_60\n",
      "getting orientation...\n",
      "rotating...\n",
      "finding cancer margins...\n",
      "Finding East margin...\n",
      "[1.]\n",
      "Finding West margin...\n",
      "[0.99998224]\n",
      "17 of 31 - BCC_61\n",
      "getting orientation...\n",
      "rotating...\n",
      "finding cancer margins...\n",
      "Finding East margin...\n",
      "[0.9999831]\n",
      "Finding West margin...\n",
      "[0.99994564]\n",
      "18 of 31 - IEC_34\n",
      "getting orientation...\n",
      "rotating...\n",
      "finding cancer margins...\n",
      "Finding East margin...\n",
      "[0.99994135]\n",
      "Finding West margin...\n",
      "[0.99999976]\n",
      "19 of 31 - IEC_35\n",
      "getting orientation...\n",
      "rotating...\n",
      "finding cancer margins...\n",
      "Finding East margin...\n",
      "[0.9999726]\n",
      "Finding West margin...\n",
      "[0.9999689]\n",
      "20 of 31 - BCC_23\n",
      "getting orientation...\n",
      "rotating...\n",
      "finding cancer margins...\n",
      "Finding East margin...\n",
      "[0.99999356]\n",
      "Finding West margin...\n",
      "[0.9999988]\n",
      "21 of 31 - BCC_24\n",
      "getting orientation...\n",
      "rotating...\n",
      "finding cancer margins...\n",
      "Finding East margin...\n",
      "[0.9999939]\n",
      "Finding West margin...\n",
      "[0.9999032]\n"
     ]
    }
   ],
   "source": [
    "pos = 10\n",
    "for step, fname in enumerate(images[pos::]):\n",
    "    \n",
    "    try:\n",
    "        print(step+1, \"of\", len(images), \"-\", fname)\n",
    "\n",
    "        segmentation = io.imread(os.path.join(seg_dir, fname) + \".png\")\n",
    "        image = io.imread(os.path.join(image_dir, fname) + \".tif\")\n",
    "\n",
    "        # Get orientation\n",
    "        print(\"getting orientation...\")\n",
    "        theta, _, p1, p2 = get_orientation(segmentation)\n",
    "\n",
    "        # Rotate images\n",
    "        print(\"rotating...\")\n",
    "        rot_segmentation = rotate_image(segmentation, theta, 0, median_filter=True)\n",
    "        rot_image = rotate_image(image, theta, 255, median_filter=False)\n",
    " \n",
    "        # Get Surgical Margins\n",
    "        print(\"finding cancer margins...\")\n",
    "        (xN, yN), (xS, yS), (xE, yE), (xW, yW) = get_cancer_margins(rot_segmentation)\n",
    "        #(xE_tissue, yE_tissue), (xW_tissue, yW_tissue) = get_tissue_margins(rot_segmentation)\n",
    "        print(\"Finding East margin...\")\n",
    "        (xE_tissue, yE_tissue) = get_tissue_margin(rot_segmentation, east=True)\n",
    "        print(\"Finding West margin...\")\n",
    "        (xW_tissue, yW_tissue) = get_tissue_margin(rot_segmentation, east=False)\n",
    "\n",
    "        # Show results\n",
    "        fig = plt.figure(figsize=(24, 36))\n",
    "        gs = mpl.gridspec.GridSpec(2, 2, wspace=0.25, hspace=0.25) # 2x2 grid\n",
    "        ax1 = fig.add_subplot(gs[0, 0]) # first row, first col\n",
    "        ax2 = fig.add_subplot(gs[0, 1]) # first row, second col\n",
    "        ax3 = fig.add_subplot(gs[1, :]) # full second row\n",
    "\n",
    "        # Plot original segmentation\n",
    "        ax1.imshow(segmentation)\n",
    "        ax1.scatter(p1[0], p1[1], s=30, color=\"red\")\n",
    "        ax1.scatter(p2[0], p2[1], s=30, color=\"red\")\n",
    "        ax1.plot([p1[0], p2[0]], [p1[1], p2[1]], lw=2, color=\"red\")\n",
    "        ax1.set_title(\"Original Segmentation\")\n",
    "        ax1.axis(\"off\")\n",
    "\n",
    "        # Plot rotated segmentation\n",
    "        ax2.imshow(rot_segmentation)\n",
    "        ax2.set_title(\"Rotate: -{0:.0f} degrees\".format(abs(theta)))\n",
    "        ax2.axis(\"off\")\n",
    "\n",
    "        # Plot cancer margins on input image\n",
    "        ax3.imshow(rot_image)\n",
    "        \n",
    "        # Add cancer contour\n",
    "        cancer = np.logical_or(\n",
    "                        np.all(rot_segmentation == color_dict[\"BCC\"], axis=-1),\n",
    "                        np.logical_or(np.all(rot_segmentation == color_dict[\"SCC\"], axis=-1),\n",
    "                                           np.all(rot_segmentation == color_dict[\"IEC\"], axis=-1)\n",
    "                                     )\n",
    "                    ) \n",
    "        ax3.contour(cancer, linewidths=1, colors=[green], linestyles=\"dashed\")\n",
    "        \n",
    "        # Plot Cancer Margins\n",
    "        ax3.scatter(xN, yN, s=100, color=\"red\", marker=\"$+$\", label=\"Superficial Margin\")\n",
    "        ax3.scatter(xS, yS, s=100, color=\"red\", marker=\"$-$\", label=\"Deep Margin\")\n",
    "        ax3.scatter(xE, yE, s=30, color=green, )#label=\"Cancer E\")\n",
    "        ax3.scatter(xW, yW, s=30, color=green, )#label=\"Cancer W\")\n",
    "\n",
    "        # Plot tissue margins\n",
    "        ax3.scatter(xE_tissue, yE_tissue, s=30, color=green) #, label=\"Tissue E\")\n",
    "        ax3.scatter(xW_tissue, yW_tissue, s=30, color=green) #, label=\"Tissue E\")\n",
    "\n",
    "        factor=10\n",
    "        east_dist =  np.round(np.sqrt( (yE_tissue-yE)**2 + (xE_tissue-xE)**2)*ppmm*factor, 1)\n",
    "        west_dist =  np.round(np.sqrt( (yW_tissue-yW)**2 + (xW_tissue-xW)**2)*ppmm*factor, 1)\n",
    "        \n",
    "        # Draw measurement lines\n",
    "        ax3.plot([xE, xE_tissue],[yE, yE_tissue], lw=1, color=green, label=\"East Margin: {0}mm\".format(east_dist))\n",
    "        ax3.plot([xW, xW_tissue],[yW, yW_tissue], lw=1, color=green, label=\"West Margin: {0}mm\".format(west_dist))\n",
    "        ax3.axis(\"off\")\n",
    "        ax3.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n",
    "        \n",
    "        # Save\n",
    "        plt.savefig(os.path.join(out_dir, fname + \".png\"), dpi=300)\n",
    "        plt.close()\n",
    "        #plt.show()\n",
    "        \n",
    "    except Exception as e:\n",
    "        print(\"FAILED...\", e)\n",
    "        continue\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f5f4828d908>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(rot_segmentation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f5f48217320>"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(rot_image)"
   ]
  }
 ],
 "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}