segmentation_color.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "linear-british",
   "metadata": {},
   "source": [
    "# Segmentation using color spaces"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "demonstrated-springfield",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Libraries\n",
    "import cv2 as cv\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.patches as mpatches\n",
    "from matplotlib.colors import hsv_to_rgb\n",
    "import numpy as np\n",
    "import os\n",
    "import glob\n",
    "import yaml\n",
    "\n",
    "# Scikit-image\n",
    "from skimage.color import rgb2gray\n",
    "from skimage.filters import threshold_otsu\n",
    "from skimage.segmentation import clear_border\n",
    "from skimage.measure import label, regionprops\n",
    "from skimage.morphology import closing, square\n",
    "from skimage.color import label2rgb\n",
    "from skimage import metrics\n",
    "\n",
    "# Validation\n",
    "from diceCoeff import dice\n",
    "from scipy.spatial.distance import directed_hausdorff\n",
    "\n",
    "from dictionary_manager import get_index\n",
    "from dictionary_manager import get_serial_dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "protected-newman",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_images(img):\n",
    "    fig, ax = plt.subplots(1, len(img), constrained_layout=True, figsize=(20,10))\n",
    "    counter = 0\n",
    "    for serial, image in img.items():\n",
    "        ax[counter].imshow(image)\n",
    "        ax[counter].set_title(serial)\n",
    "        ax[counter].set_axis_off()\n",
    "        counter += 1\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "bored-bubble",
   "metadata": {},
   "outputs": [],
   "source": [
    "def colorRemoval(img, lower_1, upper_1, lower_2, upper_2):\n",
    "    \n",
    "    # Transforming image to HSV color space\n",
    "    img_hsv = cv.cvtColor(img, cv.COLOR_BGR2HSV)\n",
    "\n",
    "    # lower mask\n",
    "    mask0 = cv.inRange(img_hsv, lower_1, upper_1)\n",
    "\n",
    "    # upper mask\n",
    "    mask1 = cv.inRange(img_hsv, lower_2, upper_2)\n",
    "\n",
    "    # join masks. This segments the image for the color red\n",
    "    mask = mask0+mask1\n",
    "    \n",
    "    kernel = np.ones((3,3),np.uint8) # 5x5 kernel\n",
    "\n",
    "    dilate = cv.dilate(mask, kernel, iterations = 10)\n",
    "    \n",
    "    # delete the green screen and keep the object in the image\n",
    "    mask_not = cv.bitwise_not(dilate)\n",
    "    \n",
    "    # Remove outliers with mophological filter\n",
    "    dilate = cv.dilate(mask_not, kernel, iterations = 10)\n",
    "    \n",
    "    result = cv.bitwise_and(img, img, mask=dilate)\n",
    "       \n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "alleged-omaha",
   "metadata": {},
   "source": [
    "## Segmenting the biggest element\n",
    "\n",
    "We are going to further segment the image into the biggest area detected, then we are going to draw a bounding box of the biggest connected elements and delete the smaller ones."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "satisfactory-calvin",
   "metadata": {},
   "outputs": [],
   "source": [
    "def regionInterest(color_segmented):\n",
    "\n",
    "    grayscale = rgb2gray(color_segmented)\n",
    "\n",
    "    # apply threshold\n",
    "    thresh = threshold_otsu(grayscale)\n",
    "\n",
    "    bw = closing(grayscale > thresh, square(3))\n",
    "\n",
    "    # remove artifacts connected to image border\n",
    "    cleared = clear_border(bw)\n",
    "\n",
    "    # label image regions\n",
    "    label_image = label(cleared)\n",
    "    # to make the background transparent, pass the value of `bg_label`,\n",
    "    # and leave `bg_color` as `None` and `kind` as `overlay`\n",
    "    image_label_overlay = label2rgb(label_image, image=grayscale, bg_label=0)\n",
    "\n",
    "    region = largest_area(regionprops(label_image)) # take the region with largest area\n",
    "\n",
    "#     print('Biggest area detected: ' + str(region.area) + ' pixels')\n",
    "    coords = region.coords\n",
    "    # draw rectangle around segmented area\n",
    "    minr, minc, maxr, maxc = region.bbox\n",
    "    rect = mpatches.Rectangle((minc, minr), maxc - minc, maxr - minr, fill=False, edgecolor='red', linewidth=2)\n",
    "    \n",
    "    return coords, image_label_overlay, rect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "narrative-gamma",
   "metadata": {},
   "outputs": [],
   "source": [
    "def largest_area(array):\n",
    "    # Initialize maximum element\n",
    "    max = array[0].area\n",
    "    region = array[0]\n",
    "  \n",
    "    # Traverse array elements from second\n",
    "    # and compare every element with \n",
    "    # current max\n",
    "    for i in range(1, len(array)):\n",
    "        if array[i].area > max:\n",
    "            max = array[i].area\n",
    "            region = array[i]\n",
    "    return region"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "official-plaza",
   "metadata": {},
   "outputs": [],
   "source": [
    "def patch_image(img_coords):    \n",
    "    fig, ax = plt.subplots(1, len(img_coords), constrained_layout=True, figsize=(20,10))\n",
    "    counter = 0\n",
    "    for serial, items in img_coords.items():\n",
    "        ax[counter].imshow(items[1])\n",
    "        ax[counter].add_patch(items[2])\n",
    "        ax[counter].set_title(serial)\n",
    "        ax[counter].set_axis_off()\n",
    "        counter += 1\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "beautiful-jewel",
   "metadata": {},
   "outputs": [],
   "source": [
    "def maskObject(img, coords):\n",
    "    \n",
    "    mask = np.zeros(img.shape[:2], dtype = \"uint8\")\n",
    "\n",
    "    for n in range(len(coords)):\n",
    "        mask[coords[n][0],coords[n][1]] = 255\n",
    " \n",
    "    return mask"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "auburn-peter",
   "metadata": {},
   "source": [
    "## Smooth edges\n",
    "\n",
    "Right now the edges are sharp and noisy, we are going to use a median filter to smooth the edges to create a clean mask for the segmentation.\n",
    "We also upscale the image to perform the median filter to a higher resolution image, afterwards the image is downscaled to the original resolution. Since the median filter is outputing an grayscale image, we need to convert it back to a binary image for the mask to work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "parental-wisdom",
   "metadata": {},
   "outputs": [],
   "source": [
    "def smoothEdges(mask, kernel = 15, iterations = 10):\n",
    "    \n",
    "    median = mask\n",
    "    # Remove noise by blurring with a Median filter\n",
    "    for n in range(iterations):\n",
    "         median =  cv.medianBlur(median,kernel) # The kernel is the size of the filter, by default 15x15\n",
    "\n",
    "    thresh_mask = cv.threshold(median, 0, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)[1]\n",
    "    \n",
    "    return thresh_mask"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "grand-turner",
   "metadata": {},
   "source": [
    "## Removing edges to delete point cloud outliers \n",
    "\n",
    "Up until this point, Dice coefficient and Hausdorff distance seem pretty good. The numbers are pretty close to the ground truth segmentation, but the masks need an additional trim along the edges, because when converting the images into point clouds, there might be outliers due to improper segmentation. So the bestway to avoid this is to remove the edges with the cv.erode() function to avoid noise when converting into point clouds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "appropriate-beverage",
   "metadata": {},
   "outputs": [],
   "source": [
    "def erosion(mask, iteration = 10):\n",
    "    kernel = np.ones((3,3),np.uint8) # 3x3 kernel\n",
    "    erosion = cv.erode(mask, kernel, iterations = iteration)\n",
    "    \n",
    "    return erosion"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "human-screen",
   "metadata": {},
   "source": [
    "## Color range selection\n",
    "\n",
    "We are going to pick a range of colors that fit the green from the tablecloth. We can display these color sets for the selected lower and upper bounds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "european-latex",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def color_selection():\n",
    "    # lower mask (50-80)\n",
    "    color_selection.lower_1_green = np.array([55,100,20])\n",
    "    color_selection.upper_1_green = np.array([80,255,255])\n",
    "\n",
    "    # upper mask (80-110)\n",
    "    color_selection.lower_2_green = np.array([80,100,20])\n",
    "    color_selection.upper_2_green = np.array([100,255,255])\n",
    "\n",
    "    lower_1_square = np.full((10, 10, 3), color_selection.lower_1_green, dtype=np.uint8) / 255.0\n",
    "    upper_1_square = np.full((10, 10, 3), color_selection.upper_1_green, dtype=np.uint8) / 255.0\n",
    "\n",
    "    lower_2_square = np.full((10, 10, 3), color_selection.lower_2_green, dtype=np.uint8) / 255.0\n",
    "    upper_2_square = np.full((10, 10, 3), color_selection.upper_2_green, dtype=np.uint8) / 255.0\n",
    "    \n",
    "    # display color selection\n",
    "    fig, ax = plt.subplots(nrows=2, ncols=2)\n",
    "\n",
    "    ax[0,0].set_title(\"Lower Bound\")\n",
    "    ax[0,0].imshow(hsv_to_rgb(lower_1_square))\n",
    "    ax[0,1].imshow(hsv_to_rgb(upper_1_square))\n",
    "\n",
    "    ax[0,1].set_title(\"Upper Bound\")\n",
    "    ax[1,0].imshow(hsv_to_rgb(lower_2_square))\n",
    "    ax[1,1].imshow(hsv_to_rgb(upper_2_square))\n",
    "\n",
    "    for a in ax.ravel():\n",
    "        a.set_axis_off()\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "democratic-chinese",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "color_selection()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "current-algorithm",
   "metadata": {},
   "source": [
    "## Save the images\n",
    "\n",
    "Then we save the images for later deprojection and create a point cloud with .ply format."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "ecological-packet",
   "metadata": {},
   "outputs": [],
   "source": [
    "def segmentation(path2images):\n",
    "    images = glob.glob(path2images + '/*.png')\n",
    "    \n",
    "    # Get the indices from the images folder corresponding to color and depth images\n",
    "    colorf_index = get_index('cfondo_color', images)\n",
    "    # Obtain the path of the corresponding indices for color and depth images\n",
    "    colorf_files = [images[i] for i in colorf_index]\n",
    "    \n",
    "    \n",
    "    # Get the indices from the images folder corresponding to color and depth images\n",
    "    color_index = get_index('sfondo_color', images)\n",
    "    # Obtain the path of the corresponding indices for color and depth images\n",
    "    color_files = [images[i] for i in color_index]\n",
    "    \n",
    "    file_name = path2images + '/' + 'intrinsics_matrix.yaml'\n",
    "    with open(file_name, 'r') as file:\n",
    "        intrinsics_matrix = yaml.safe_load(file)\n",
    "        \n",
    "    \n",
    "    serial_colorf_path = get_serial_dictionary(colorf_files, intrinsics_matrix)\n",
    "    serial_color_path = get_serial_dictionary(color_files, intrinsics_matrix)\n",
    "    \n",
    "    imgf = {}\n",
    "    for serial, path in serial_colorf_path.items():\n",
    "        imgf[serial] = cv.imread(path)\n",
    "        \n",
    "    print('Original images')\n",
    "    plot_images(imgf)    \n",
    "    \n",
    "    img = {}\n",
    "    for serial, path in serial_color_path.items():\n",
    "        img[serial] = cv.imread(path)\n",
    "     \n",
    "    print('No background images')\n",
    "    plot_images(img)\n",
    "       \n",
    "    seg_color = {}\n",
    "    for serial, images in img.items():\n",
    "        seg_color[serial] = colorRemoval(images, color_selection.lower_1_green, color_selection.upper_1_green, color_selection.lower_2_green, color_selection.upper_2_green)\n",
    "    \n",
    "    print('Color segmented')\n",
    "    plot_images(seg_color)\n",
    "    \n",
    "    coords = {}\n",
    "    counter = 0\n",
    "    for serial, segmented in seg_color.items():\n",
    "        coords[serial] = regionInterest(segmented)\n",
    "    \n",
    "    print('Region segmented')\n",
    "    patch_image(coords)\n",
    "    \n",
    "    mask = {}  \n",
    "    for serial, coordinates in coords.items():\n",
    "        mask[serial] = maskObject(img[serial], coordinates[0])\n",
    "    \n",
    "    print('Mask')\n",
    "    plot_images(mask)\n",
    "      \n",
    "    mask_smooth = {}\n",
    "    for serial, masked in mask.items():\n",
    "        mask_smooth[serial] = smoothEdges(masked)       \n",
    "    \n",
    "    segmentation.mask_smooth = mask_smooth\n",
    "    print('Mask smooth edges')   \n",
    "    plot_images(mask_smooth)\n",
    "    \n",
    "    mask_erosion = {}\n",
    "    for serial, mask in segmentation.mask_smooth.items():\n",
    "        mask_erosion[serial] = erosion(mask)\n",
    "    print('Mask erosion')\n",
    "    plot_images(mask_erosion)\n",
    "    \n",
    "    result = {}\n",
    "    for serial, masked in mask_smooth.items():\n",
    "        result[serial] = cv.bitwise_and(img[serial], img[serial], mask=mask_erosion[serial])\n",
    "    \n",
    "    print('Result images')\n",
    "    plot_images(result)\n",
    "    \n",
    "    serial_segment_path = {}\n",
    "    for serial, path in serial_color_path.items():\n",
    "        serial_segment_path[serial] = path.replace('color', 'segment') \n",
    "        \n",
    "    for serial, path in serial_segment_path.items():\n",
    "        cv.imwrite(path, result[serial])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "outer-instrumentation",
   "metadata": {},
   "source": [
    "## Segmentation Validation\n",
    "\n",
    "Now we need to ensure, that our segmentation is has been performed as desired, to do so, we need a comparison between our result obtain throught the previous algorithms and another segmentation method. This other segmentation method was obtained using the laso tool in Photoshop. To validate our segmentation we are going to use the Dice Coefficient, which compares a set similarity, where 1 means that both sets are equal and 0 that they are completely different."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "global-funeral",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fetch_images(path):\n",
    "    images = glob.glob(path + '/*.png')\n",
    "    \n",
    "    # Get the indices from the images folder corresponding to color and depth images\n",
    "    color_index = get_index('target', images)\n",
    "    # Obtain the path of the corresponding indices for color and depth images\n",
    "    color_files = [images[i] for i in color_index]\n",
    "    \n",
    "    file_name = path + '/' + 'intrinsics_matrix.yaml'\n",
    "    with open(file_name, 'r') as file:\n",
    "        intrinsics_matrix = yaml.safe_load(file)\n",
    "        \n",
    "    serial_color_path = get_serial_dictionary(color_files, intrinsics_matrix)\n",
    "    \n",
    "    img = {}\n",
    "    for serial, paths in serial_color_path.items():\n",
    "        img[serial] = cv.imread(paths, 0)\n",
    "        \n",
    "    plot_images(img)\n",
    "    \n",
    "    return img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "european-falls",
   "metadata": {},
   "outputs": [],
   "source": [
    "def segmentation_validation(img):\n",
    "    dice_coeff = {}\n",
    "    for serial, segmented in img.items():\n",
    "        dice_coeff[serial] = dice(segmented, segmentation.mask_smooth[serial])\n",
    "    \n",
    "    segmentation_validation.dice_coeff = dice_coeff\n",
    "    \n",
    "    hausdorff = {}\n",
    "    for serial, segmented in img.items():\n",
    "        hausdorff[serial] = metrics.hausdorff_distance(segmented, segmentation.mask_smooth[serial])\n",
    "        \n",
    "    segmentation_validation.hausdorff = hausdorff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "standing-local",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_validation(img):\n",
    "    assert(len(img) == len(segmentation.mask_smooth))\n",
    "    fig, ax = plt.subplots(2, len(img), figsize=(14, 4), sharex=True, sharey=True)\n",
    "    ax = ax.ravel()\n",
    "    label = 'Dice: {:.4f}, HD: {:.4f}'\n",
    "    counter = 0\n",
    "    ax[counter].set_ylabel(\"Ground Truth\")\n",
    "    for serial, image in img.items():\n",
    "        ax[counter].imshow(image)\n",
    "        ax[counter].set_title(serial)\n",
    "        counter += 1\n",
    "        \n",
    "    ax[counter].set_ylabel(\"Algorithms\")    \n",
    "    for serial, image in segmentation.mask_smooth.items():\n",
    "        ax[counter].imshow(image)\n",
    "        ax[counter].set_xlabel(label.format(segmentation_validation.dice_coeff[serial], segmentation_validation.hausdorff[serial]))\n",
    "        counter += 1  \n",
    "        \n",
    "    fig.suptitle('Dice Coefficients & Hausdorff Distances', fontsize=16)\n",
    "    plt.tight_layout()\n",
    "    \n",
    "    output_file = path + \"/seg_validation.svg\"\n",
    "    plt.savefig(output_file,\n",
    "            bbox_inches =\"tight\",\n",
    "            transparent = True,\n",
    "            facecolor =\"w\",\n",
    "            edgecolor ='w',\n",
    "            orientation ='landscape')\n",
    "    \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "unique-elevation",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "truth_segmentation = fetch_images(path)\n",
    "segmentation_validation(truth_segmentation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "legitimate-denver",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x288 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_validation(truth_segmentation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "applied-platinum",
   "metadata": {},
   "outputs": [],
   "source": [
    "mask_erosion = {}\n",
    "for serial, mask in segmentation.mask_smooth.items():\n",
    "    mask_erosion[serial] = erosion(mask)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "moderate-huntington",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x288 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_validation(mask_erosion)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "european-leader",
   "metadata": {},
   "source": [
    "## References\n",
    "\n",
    "* [Color Segmentation - Python](https://realpython.com/python-opencv-color-spaces/)\n",
    "* [Color Filtering - HSV](https://cvexplained.wordpress.com/2020/04/28/color-detection-hsv/)\n",
    "* [Label image regions - Scikitimage](https://scikit-image.org/docs/dev/auto_examples/segmentation/plot_label.html)\n",
    "* [Dice coefficient - Numpy](https://gist.github.com/JDWarner/6730747)\n",
    "* [Hausdorff distance - Scipy](https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.distance.directed_hausdorff.html)\n",
    "* [Hausdorff distance - Scikit Image](https://scikit-image.org/docs/0.18.x/auto_examples/segmentation/plot_hausdorff_distance.html#sphx-glr-auto-examples-segmentation-plot-hausdorff-distance-py)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1a1664f3-1d96-4759-86c4-ca9f31f2392f",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}