main.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2 as cv\n",
    "import watershedOpenCV as wa\n",
    "import customAlgorithm as ca\n",
    "\n",
    "loadableVideos = {\"Toucan\" : 1, \"Dino\" : 2, \"Cracker\" : 3, \"Ganesh\" : 4}\n",
    "\n",
    "# Variables to set to choose the algorithm and the video to load\n",
    "videoToLoad = loadableVideos[\"Ganesh\"]  # Choose one among the keys in loadableVideos\n",
    "chosenAlgorithm = \"watershed\" # \"custom\" or \"watershed\"\n",
    "\n",
    "# Open the video reader and read the first frame, if available\n",
    "videoReader = cv.VideoCapture(\"../data/obj0\" + str(videoToLoad) + \".mp4\")\n",
    "success, image = videoReader.read()\n",
    "\n",
    "# Choose the algorithm for the execution.\n",
    "algorithm = wa.watershedSegmentation if chosenAlgorithm == \"watershed\" else ca.multiSpaceSegmentation\n",
    "\n",
    "# Set the video format to mp4, as for the original videos\n",
    "videoFormat = cv.VideoWriter_fourcc(\"m\", \"p\", \"4\", \"v\")\n",
    "\n",
    "# Start an OpenCV videowriter to write the frames on the new video.\n",
    "# I always set the 29.97 fps and 1920x1080 for each video because every original video has such parameters.\n",
    "videoWriter = cv.VideoWriter(\"../data/obj0\" + str(videoToLoad) + \"_mask.mp4\", videoFormat, 29.97, (1920, 1080))\n",
    "\n",
    "while (success and videoReader.isOpened()):\n",
    "    \"\"\"Transform the frame just read and save it at the same time as new frame for the \n",
    "    new video.\n",
    "    \"\"\"\n",
    "    videoWriter.write(algorithm(image))\n",
    "    success, image = videoReader.read()\n",
    "\n",
    "videoWriter.release()\n",
    "videoReader.release()\n",
    "cv.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now I compare the results of the two methods I built against the ground truth masks:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WatershedOpenCV segmentation achieves an accuracy of 0.9792389724794238.\n",
      "Multi space segmentation achieves an accuracy of 0.9962096514917695.\n",
      "\n",
      "WatershedOpenCV segmentation achieves a precision of 0.9924746044098574.\n",
      "Multi space segmentation achieves a precision of 0.9936587544571787.\n",
      "\n",
      "WatershedOpenCV segmentation achieves a recall of 0.9639245673144333.\n",
      "Multi space segmentation achieves a recall of 0.998451132435567.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import (\n",
    "    confusion_matrix,\n",
    "    ConfusionMatrixDisplay,\n",
    "    accuracy_score,\n",
    "    precision_score,\n",
    "    recall_score,\n",
    ")\n",
    "import cv2 as cv\n",
    "import watershedOpenCV as wa\n",
    "import customAlgorithm as ca\n",
    "from os import listdir\n",
    "from numpy import array\n",
    "\n",
    "from copy import deepcopy\n",
    "\n",
    "\"\"\"cv2, watershedOpenCV and customAlgorithm are imported again to allows the execution \n",
    "of just the performance examination chunk.\n",
    "\"\"\"\n",
    "\n",
    "# Retrieve every test frame (both ground truth and frames to transform)\n",
    "testDataset = [\n",
    "    cv.imread(\"../assignment1_test_dataset/obj0\" + str(videoIndex) + \"/\" + fileName)\n",
    "    for videoIndex in [1, 2, 4]\n",
    "    for fileName in listdir(\"../assignment1_test_dataset/obj0\" + str(videoIndex) + \"/\")\n",
    "]\n",
    "\n",
    "# This binarization is necessary because groundTruthTestMasks images include also other values\n",
    "# than 255 and 0.\n",
    "def binarizeIntensityFrame(frame):\n",
    "    frame[frame != 0] = 255\n",
    "    return frame\n",
    "\n",
    "# Store the ground trouth frames\n",
    "groundTruthTestMasks = testDataset[1::2]\n",
    "# Compute the \"multi-space\" and watershed segmented images. The deepcopy was necessary\n",
    "# otherwise multiSpaceSegmentation would have modified testDataset, and hence compromised\n",
    "# the results of watershedSegmentation.\n",
    "customComputedTestMasks = [ca.multiSpaceSegmentation(rawTestFrame) for rawTestFrame in deepcopy(testDataset[0::2])]\n",
    "watershedComputedTestMasks = [wa.watershedSegmentation(rawTestFrame) for rawTestFrame in deepcopy(testDataset[0::2])]\n",
    "\n",
    "# Convert the 3 sets of images to gray scale with 2 values (0 and 255), to have an\n",
    "# easier correspondence with Negative and Positive classes.\n",
    "for index in range(len(groundTruthTestMasks)):\n",
    "    groundTruthTestMasks[index] = binarizeIntensityFrame(cv.cvtColor(groundTruthTestMasks[index], cv.COLOR_BGR2GRAY))\n",
    "    watershedComputedTestMasks[index] = cv.cvtColor(watershedComputedTestMasks[index], cv.COLOR_BGR2GRAY)\n",
    "    customComputedTestMasks[index] = cv.cvtColor(customComputedTestMasks[index], cv.COLOR_BGR2GRAY)\n",
    "\n",
    "# Linearize the arrays to compare them pixel by pixel.\n",
    "groundTruthTestMasks = array(groundTruthTestMasks).ravel()\n",
    "watershedComputedTestMasks = array(watershedComputedTestMasks).ravel()\n",
    "customComputedTestMasks = array(customComputedTestMasks).ravel()\n",
    "\n",
    "watershedAccuracy = accuracy_score(groundTruthTestMasks, watershedComputedTestMasks)\n",
    "customAccuracy = accuracy_score(groundTruthTestMasks, customComputedTestMasks)\n",
    "\n",
    "print(f\"WatershedOpenCV segmentation achieves an accuracy of {watershedAccuracy}.\")\n",
    "print(f\"Multi space segmentation achieves an accuracy of {customAccuracy}.\\n\")\n",
    "\n",
    "watershedPrecision = precision_score(groundTruthTestMasks, watershedComputedTestMasks, pos_label=255)\n",
    "customPrecision = precision_score(groundTruthTestMasks, customComputedTestMasks, pos_label=255)\n",
    "\n",
    "print(f\"WatershedOpenCV segmentation achieves a precision of {watershedPrecision}.\")\n",
    "print(f\"Multi space segmentation achieves a precision of {customPrecision}.\\n\")\n",
    "\n",
    "watershedRecall = recall_score(groundTruthTestMasks, watershedComputedTestMasks, pos_label=255)\n",
    "customRecall = recall_score(groundTruthTestMasks, customComputedTestMasks, pos_label=255)\n",
    "\n",
    "print(f\"WatershedOpenCV segmentation achieves a recall of {watershedRecall}.\")\n",
    "print(f\"Multi space segmentation achieves a recall of {customRecall}.\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I print, as requested, the following scores: \n",
    " - The accuracy which is the accuracy of the classification of each pixel. \n",
    "\n",
    " - The precision which is the ability of the classifier not to label as positive a sample that is negative.It is calculated as follows: \n",
    "    tp/(tp + fp) where tp is the number of true positives and fp the number of false positives.\n",
    "\n",
    " - The recall which is the ability of the classifier to find all the positive samples. It it computed as follows: \n",
    "   tp / (tp + fn) where tp is the number of true positives and fn the number of false \n",
    "   negatives.\n",
    "   \n",
    " In my case I got that on average the \"multiSpace\" algorithm scores better than the watershed algorithm of OpenCv, in particular I got that: \n",
    " - The precision is very similar and high for both methods. \n",
    " - The recall and accuracy performs a few points better in the \"multiSpace\" algorithm, although they score very well also with watershed. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's focus on the confusion matrices related to the two methods. First we give a look to the Watershed matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "watershedCf = confusion_matrix(groundTruthTestMasks, watershedComputedTestMasks)\n",
    "customCf = confusion_matrix(groundTruthTestMasks, customComputedTestMasks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "watershedCfDisplay = ConfusionMatrixDisplay(\n",
    "    watershedCf, display_labels=[\"Negative\", \"Positive\"]\n",
    ")\n",
    "\n",
    "watershedCfDisplay.plot()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we are going to see the Custom Algorithm's confusion matrix: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "customCfDisplay = ConfusionMatrixDisplay(\n",
    "    customCf, display_labels=[\"Negative\", \"Positive\"]\n",
    ")\n",
    "\n",
    "customCfDisplay.plot()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see in the both matrices above, we have a good balance, since we have that:\n",
    " - The true positive (tp), which refers to a sample correctly classified positive, \n",
    "   and the true negative (tn), which refers to a sample correctly classified as negative, both have a high value. \n",
    " - Instead, as expected, both false positives (fp) and false negatives (fn) have low values. \n",
    "\n",
    "In particular, we have that:\n",
    " - the customAlgorithm has a much better confusion matrix than the watershedOpenCv. \n",
    " - tp of customAlgorithm's confusion matrix are around 1.5e+07 against 1.4e+07 of watershedOpenCv's confusion matrix.\n",
    " - tn of customAlgorithm's confusion matrix are the same as those of watershedOpenCv's confusion matrix, that is, 1.6e+07.\n",
    " - fp of customAlgorithm's confusion matrix are around 94841 versus 108789 of watershedOpenCv's confusion matrix.\n",
    " - fn of customAlgorithm's confusion matrix are around 23054 against 536962 of watershedOpenCv's confusion matrix."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.10 64-bit",
   "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.8.10"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}