grp-XXX-0005code.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# COMP0005 - GROUP COURSEWORK 2023-24\n",
    "# Gesture Recognition via Convex Hull "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the cell below for all python code needed to realise the **Jarvis march algorithm** (including auxiliary data structures and functions needed by this algorithm - if any). The `jarvismarch()` function itself should take as input parameter a list of 2D points (`inputSet`), and return the subset of such points (`outputSet`) that lie on the convex hull."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import pi, atan2 # for computing polar angle\n",
    "\n",
    "class GraphUtils():    \n",
    "    def orientation(a, b, c):\n",
    "        val = (b[1] - a[1]) * (c[0] - b[0]) - (b[0] - a[0]) * (c[1] - b[1])\n",
    "        # return 0 if collinear\n",
    "        if val == 0:\n",
    "            return 0\n",
    "        # return 1 if counterclockwise orientation\n",
    "        elif val > 0:\n",
    "            return 1\n",
    "        # return -1 if clockwise orientation\n",
    "        else:\n",
    "            return -1\n",
    "        \n",
    "    def getMinY(points):\n",
    "        min = points[0]\n",
    "        for point in points:\n",
    "            if point[1] < min[1]:\n",
    "                min = point\n",
    "        return min\n",
    "    \n",
    "    def dist(a, b):\n",
    "        xDiffSquare = (a[0] - b[0]) ** 2\n",
    "        yDiffSquare = (a[1] - b[1]) ** 2\n",
    "        sumSquare = (xDiffSquare + yDiffSquare) ** 2\n",
    "        return sumSquare\n",
    "    \n",
    "    def angle(a, b):\n",
    "        angle = atan2(b[1] - a[1], b[0] - a[0]) * (180 / pi)\n",
    "        if angle < 0:\n",
    "            angle += 360\n",
    "        return angle\n",
    "    \n",
    "    def isCounterClockWise(self, a, b, c):\n",
    "        return self.orientation(a,b,c) > 0\n",
    "\n",
    "    def sort_key(point, P):\n",
    "        if point == P:\n",
    "            return float('-inf'), 0\n",
    "        currAngle = GraphUtils.angle(point, P)\n",
    "        distance_squared = GraphUtils.dist(point, P)\n",
    "        return currAngle, distance_squared    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(0, -6), (5, 0), (0, 4), (-4, 0)]\n"
     ]
    }
   ],
   "source": [
    "def jarvismarch(inputSet):\n",
    "    if len(inputSet) <= 3:\n",
    "        return inputSet\n",
    "\n",
    "    hull = []\n",
    "    startPoint = GraphUtils.getMinY(inputSet)\n",
    "    hull.append(startPoint)\n",
    "    prev = startPoint\n",
    "    prevAngle = -1\n",
    "    while(True):\n",
    "        minAngle = float('inf')\n",
    "        maxDist = 0\n",
    "        next = None\n",
    "        \n",
    "        for point in inputSet:\n",
    "            if  point == prev: \n",
    "                continue\n",
    "            angle = GraphUtils.angle(prev, point)\n",
    "            dist = GraphUtils.dist(prev, point)\n",
    "            compareAngles = 0 if angle == minAngle else (-1 if angle < minAngle else 1)\n",
    "            if compareAngles <= 0 and angle > prevAngle:\n",
    "                if compareAngles < 0 or dist > maxDist:\n",
    "                    minAngle = angle\n",
    "                    maxDist = dist\n",
    "                    next = point\n",
    "\n",
    "        if next == startPoint:\n",
    "            break\n",
    "\n",
    "        hull.append(next)\n",
    "\n",
    "        prevAngle = GraphUtils.angle(prev, next)\n",
    "        prev = next\n",
    "    \n",
    "    return hull \n",
    "\n",
    "\n",
    "#points = [(-7,8), (-4,6), (2,6), (6,4), (8,6), (7,-2), (4,-6), (8,-7),(0,0), (3,- 2),(6,-10),(0,6),(-9,-5),(-8,-2),(-8,0),(-10,3),(-2,2),(-10,4)]\n",
    "points = [(0, 0), (0, 4), (-4, 0), (5, 0), (0, -6), (1, 0)]\n",
    "print(jarvismarch(points))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the cell below for all python code needed to realise the **Graham scan** algorithm (including auxiliary data structures and functions needed by this algorithm - if any). The `grahamscan()` function itself should take as input parameter a list of 2D points (`inputSet`), and return the subset of such points that lie on the convex hull (`outputSet`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(0, -6), (5, 0), (0, 4), (-4, 0)]\n"
     ]
    }
   ],
   "source": [
    "def grahamscan(inputSet):\n",
    "    '''\n",
    "    Returns the list of points that lie on the convex hull (graham scan algorithm)\n",
    "            Parameters:\n",
    "                    inputSet (list): a list of 2D points\n",
    "\n",
    "            Returns:\n",
    "                    outputSet (list): a list of 2D points\n",
    "    '''\n",
    "    if len(inputSet) <= 3:\n",
    "        return inputSet\n",
    "\n",
    "    def sort_key(point, P):\n",
    "        angle = atan2(point[1] - P[1], point[0] - P[0])\n",
    "        distance_squared = (point[0] - P[0])**2 + (point[1] - P[1])**2\n",
    "        return (angle, distance_squared)\n",
    "    \n",
    "    stack = []\n",
    "    minYPoint = GraphUtils.getMinY(inputSet)\n",
    "    inputSet.remove(minYPoint)\n",
    "    sortedInputSet = sorted(inputSet, key=lambda p: sort_key(p, minYPoint))\n",
    "    stack.append(minYPoint)\n",
    "    stack.append(sortedInputSet[0])\n",
    "\n",
    "    for i in range(1, len(sortedInputSet)):\n",
    "        next = sortedInputSet[i]\n",
    "        while len(stack) > 1 and GraphUtils.orientation(stack[-2], stack[-1], next) != -1:\n",
    "            stack.pop()\n",
    "        stack.append(next)\n",
    "\n",
    "    return stack\n",
    "\n",
    "# points = [(-7,8), (-4,6), (2,6), (6,4), (8,6), (7,-2), (4,-6), (8,-7),(0,0), (3,- 2),(6,-10),(0,6),(-9,-5),(-8,-2),(-8,0),(-10,3),(-2,2),(-10,4)]\n",
    "#points = [(0, 0), (0, 4), (-4, 0), (5, 0), (0, -6), (1, 0)]\n",
    "# points = [(1,4),(5,6),(2,10),(8,2),(-1,8),(6,3),(7,7),(4,4),(3,9)]\n",
    "\n",
    "#print(grahamscan(points))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the cell below for all python code needed to realise the **Chen's** algorithm (including auxiliary data structures and functions needed by this algorithm - if any). The `chen()` function itself should take as input parameter a list of 2D points (`inputSet`), and return the subset of such points that lie on the convex hull (`outputSet`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(-4, 0), (1, 0), (0, -6)]\n"
     ]
    }
   ],
   "source": [
    "def chen(inputSet):    \n",
    "     \n",
    "     def tangent(hull, p):\n",
    "          l = 0 #left most element in the list\n",
    "          r = len(hull) #right most element in the list\n",
    "          lPre = GraphUtils.orientation(p, hull[0], hull[-1])\n",
    "          lSucc = GraphUtils.orientation(p, hull[0], hull[(l + 1) % r])\n",
    "          while l < r:\n",
    "               m = l + ((r - l) // 2) #middle element in the list \n",
    "               mPre = GraphUtils.orientation(p, hull[m], hull[int((m - 1) % len(hull))])\n",
    "               mSucc = GraphUtils.orientation(p, hull[m], hull[int((m + 1) % len(hull))])\n",
    "               mSide = GraphUtils.orientation(p, hull[l], hull[m])\n",
    "               if mPre != -1 and mSucc != -1:\n",
    "                    return m\n",
    "               elif (mSide == 1) and (lSucc == -1 or lPre == lSucc) or (mSide == -1) and (mPre == -1):\n",
    "                    r = m              \n",
    "               else:\n",
    "                    l = m + 1           \n",
    "                    lPre = -mSucc    \n",
    "                    lSucc = GraphUtils.orientation(p, hull[l], hull[(l + 1) % len(hull)])\n",
    "          return l\n",
    "     \n",
    "     def minHullPtPair(hulls):\n",
    "          hull = 0\n",
    "          pt = 0\n",
    "          for i in range(len(hulls)):\n",
    "               j = min(range(len(hulls[i])), key=lambda j: hulls[i][j])\n",
    "               if hulls[i][j] < hulls[hull][pt]:\n",
    "                    hull = i\n",
    "                    pt = j\n",
    "          return (hull, pt)\n",
    "     \n",
    "     def nextHullPtPair(hulls, pair):\n",
    "          p = hulls[pair[0]][pair[1]]\n",
    "          next_pair = (pair[0], (pair[1] + 1) % len(hulls[pair[0]]))\n",
    "          for h in (i for i in range(len(hulls)) if i != pair[0]):\n",
    "               s = tangent(hulls[h], p)\n",
    "               q, r = hulls[next_pair[0]][next_pair[1]], hulls[h][s]\n",
    "               t = GraphUtils.orientation(p, q, r)\n",
    "               if t == -1 or (t == 0 and GraphUtils.dist(p, r) > GraphUtils.dist(p, q)):\n",
    "                    next_pair = (h, s)\n",
    "          return next_pair\n",
    "\n",
    "     for m in (1 << (1 << t) for t in range(len(inputSet))):\n",
    "          hulls = [grahamscan(inputSet[i:i+m]) for i in range(0, len(inputSet), m)]\n",
    "          hull = [minHullPtPair(hulls)]\n",
    "          for _ in range(m):\n",
    "               p = nextHullPtPair(hulls, hull[-1])\n",
    "               if p == hull[0]:\n",
    "                    return [hulls[h][i] for h,i in hull]\n",
    "               hull.append(p)\n",
    "\n",
    "# points = [(-7,8), (-4,6), (2,6), (6,4), (8,6), (7,-2), (4,-6), (8,-7),(0,0), (3,- 2),(6,-10),(0,6),(-9,-5),(-8,-2),(-8,0),(-10,3),(-2,2),(-10,4)]\n",
    "#points = [(0, 0), (0, 4), (-4, 0), (5, 0), (0, -6), (1, 0)]\n",
    "# points = [(1,4),(5,6),(2,10),(8,2),(-1,8),(6,3),(7,7),(4,4),(3,9)]\n",
    "\n",
    "\n",
    "#print(chen(points))\n",
    "         "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the cell below to implement the **synthetic data generator** needed by your experimental framework (including any auxiliary data structures and functions you might need - be mindful of code readability and reusability)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import math \n",
    "class TestDataGenerator():\n",
    "    \"\"\"\n",
    "    A class to represent a synthetic data generator.\n",
    "\n",
    "    ...\n",
    "\n",
    "    Attributes\n",
    "    ----------\n",
    "    \n",
    "    [to be defined as part of the coursework]\n",
    "\n",
    "    Methods\n",
    "    -------\n",
    "    \n",
    "    [to be defined as part of the coursework]\n",
    "\n",
    "    \"\"\"\n",
    "        \n",
    "    #ADD YOUR CODE HERE\n",
    "    \n",
    "    def __init__():\n",
    "        pass\n",
    "\n",
    "    def randomPoints(n):\n",
    "        points = []\n",
    "        for i in range(n):\n",
    "            points.append((random.randint(0,32766),random.randint(0,32766)))\n",
    "\n",
    "        return points\n",
    "\n",
    "\n",
    "    def randomPointsCircle(n):\n",
    "        radius = 30000\n",
    "        points = []\n",
    "        for _ in range(n):\n",
    "            angle = 2 * math.pi * random.random()\n",
    "            x = radius * math.cos(angle)\n",
    "            y = radius * math.sin(angle)\n",
    "            points.append((x, y))\n",
    "        return points    \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the cell below to implement the requested **experimental framework** API."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import timeit\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "class ExperimentalFramework():\n",
    "    \"\"\"\n",
    "    A class to represent an experimental framework.\n",
    "\n",
    "    ...\n",
    "\n",
    "    Attributes\n",
    "    ----------\n",
    "    \n",
    "    [to be defined as part of the coursework]\n",
    "\n",
    "    Methods\n",
    "    -------\n",
    "    \n",
    "    [to be defined as part of the coursework]\n",
    "\n",
    "    \"\"\"\n",
    "        \n",
    "    #ADD YOUR CODE HERE\n",
    "    \n",
    "    def __init__():\n",
    "        pass\n",
    "\n",
    "\n",
    "    def testTiming(algo,inputSet):\n",
    "        loop = 100\n",
    "        result = timeit.timeit(lambda: algo(inputSet), number = loop, globals=globals())\n",
    "        return (result/loop)\n",
    "\n",
    "    def plotGraph1():\n",
    "\n",
    "        timingsjm = []\n",
    "        timingsgs = []\n",
    "        timingsc = []\n",
    "        for n in range(4, 500):\n",
    "            inputSet = TestDataGenerator.randomPoints(n)\n",
    "            #timingsjm.append(ExperimentalFramework.testTiming(jarvismarch, inputSet))\n",
    "            timingsgs.append(ExperimentalFramework.testTiming(grahamscan, inputSet))\n",
    "            #timingsc.append(ExperimentalFramework.testTiming(chen, inputSet))\n",
    "\n",
    "        plt.title(\"Average Case Scenario for all Algorithms\")\n",
    "        plt.xlabel(\"Number of Points\")\n",
    "        plt.ylabel(\"Time taken\")\n",
    "        plt.grid(True)\n",
    "\n",
    "        #plt.plot(range(4, 500), timingsjm)\n",
    "        plt.plot(range(4,500), timingsgs)\n",
    "        #plt.plot(range(4,500), timingsc)\n",
    "\n",
    "\n",
    "    def plotGraph2():\n",
    "\n",
    "        timingsjm = []\n",
    "        timingsgs = []\n",
    "        timingsc = []\n",
    "        for n in range(4, 500):\n",
    "            inputSet = TestDataGenerator.randomPointsCircle(n)\n",
    "            #timingsjm.append(ExperimentalFramework.testTiming(jarvismarch, inputSet))\n",
    "            timingsgs.append(ExperimentalFramework.testTiming(grahamscan, inputSet))\n",
    "            #timingsc.append(ExperimentalFramework.testTiming(chen, inputSet))\n",
    "\n",
    "        plt.title(\"Worst Case Scenario for all Algorithms\")\n",
    "        plt.xlabel(\"Number of Points\")\n",
    "        plt.ylabel(\"Time taken\")\n",
    "        plt.grid(True)\n",
    "\n",
    "        #plt.plot(range(4, 500), timingsjm)\n",
    "        plt.plot(range(4,500), timingsgs)\n",
    "        #plt.plot(range(4,500), timingsc)\n",
    "\n",
    "    \n",
    "    def plotGraph3():\n",
    "\n",
    "        timingsAC = []\n",
    "        timingsWC = []\n",
    " \n",
    "        for n in range(4, 500):\n",
    "            inputSet1 = TestDataGenerator.randomPoints(n)\n",
    "            inputSet2 = TestDataGenerator.randomPointsCircle(n)\n",
    "            timingsAC.append(ExperimentalFramework.testTiming(jarvismarch, inputSet1))\n",
    "            timingsWC.append(ExperimentalFramework.testTiming(jarvismarch, inputSet2))\n",
    "            \n",
    "\n",
    "        plt.title(\"Jarvis March Algorithm\")\n",
    "        plt.xlabel(\"Number of Points\")\n",
    "        plt.ylabel(\"Time taken\")\n",
    "        plt.grid(True)\n",
    "\n",
    "        plt.plot(range(4, 500), timingsAC)\n",
    "        plt.plot(range(4,500), timingsWC)\n",
    "        \n",
    "\n",
    "\n",
    "    def plotGraph4():\n",
    "\n",
    "        timingsAC = []\n",
    "        timingsWC = []\n",
    " \n",
    "        for n in range(4, 500):\n",
    "            inputSet1 = TestDataGenerator.randomPoints(n)\n",
    "            inputSet2 = TestDataGenerator.randomPointsCircle(n)\n",
    "            timingsAC.append(ExperimentalFramework.testTiming(grahamscan, inputSet1))\n",
    "            timingsWC.append(ExperimentalFramework.testTiming(grahamscan, inputSet2))\n",
    "            \n",
    "\n",
    "        plt.title(\"Graham's Scan Algorithm\")\n",
    "        plt.xlabel(\"Number of Points\")\n",
    "        plt.ylabel(\"Time taken\")\n",
    "        plt.grid(True)\n",
    "\n",
    "        plt.plot(range(4, 500), timingsAC)\n",
    "        plt.plot(range(4,500), timingsWC)\n",
    "\n",
    "\n",
    "    \n",
    "\n",
    "    def plotGraph5():\n",
    "\n",
    "        timingsAC = []\n",
    "        timingsWC = []\n",
    " \n",
    "        for n in range(4, 500):\n",
    "            inputSet1 = TestDataGenerator.randomPoints(n)\n",
    "            inputSet2 = TestDataGenerator.randomPointsCircle(n)\n",
    "            timingsAC.append(ExperimentalFramework.testTiming(chen, inputSet1))\n",
    "            timingsWC.append(ExperimentalFramework.testTiming(chen, inputSet2))\n",
    "            \n",
    "\n",
    "        plt.title(\"Chan's Algorithm\")\n",
    "        plt.xlabel(\"Number of Points\")\n",
    "        plt.ylabel(\"Time taken\")\n",
    "        plt.grid(True)\n",
    "\n",
    "        plt.plot(range(4, 500), timingsAC)\n",
    "        plt.plot(range(4,500), timingsWC)\n",
    "\n",
    "\n",
    "\n",
    "ExperimentalFramework.plotGraph1()\n",
    "#ExperimentalFramework.plotGraph2()\n",
    "#ExperimentalFramework.plotGraph3()\n",
    "    \n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the cell below to illustrate the python code you used to **fully evaluate** the three convex hull algortihms under considerations. The code below should illustrate, for example, how you made used of the **TestDataGenerator** class to generate test data of various size and properties; how you instatiated the **ExperimentalFramework** class to  evaluate each algorithm using such data, collect information about their execution time, plots results, etc. Any results you illustrate in the companion PDF report should have been generated using the code below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(18603, 856), (28571, 4709), (27144, 29110), (5733, 31084), (2017, 1862)]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "' \\nNOTES:\\n\\n1)JARVIS MARCH GIVING WRONG OUTPUT MOST OF THE TIME AND FAILING SOMETIMES\\n\\n2)CHAN FAILING \\n\\n3)1 GRAPH WITH AVG AND WORST CASE FOR EVERY ALGO, 1 GRAPH WITH AVG CASE OF ALL ALGOS, 1 GRAPH WITH WORST CASE OF ALL ALGOS.\\n\\n4)FIGURE OUT HOW TO PLOT MORE THAN 1 GRAPHS '"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ADD YOUR TEST CODE HERE \n",
    "\n",
    "points = TestDataGenerator.randomPoints(10)\n",
    "\n",
    "\n",
    "#print(chen(points))\n",
    "#print(grahamscan(points))\n",
    "print(jarvismarch(points))\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\"\"\" \n",
    "NOTES:\n",
    "\n",
    "1)JARVIS MARCH GIVING WRONG OUTPUT MOST OF THE TIME \n",
    "\n",
    "2)CHAN FAILING \n",
    "\n",
    "3)1 GRAPH WITH AVG AND WORST CASE FOR EVERY ALGO, 1 GRAPH WITH AVG CASE OF ALL ALGOS, 1 GRAPH WITH WORST CASE OF ALL ALGOS.\n",
    "\n",
    "4)FIGURE OUT HOW TO PLOT MORE THAN 1 GRAPHS \"\"\""
   ]
  }
 ],
 "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.12.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}