hand_gesture_recognition.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some useful links from Dana:\n",
    "\n",
    "https://scikit-image.org/docs/stable/auto_examples/edges/plot_skeleton.html\n",
    "\n",
    "https://nalinc.github.io/blog/2018/skin-detection-python-opencv/\n",
    "\n",
    "https://docs.opencv.org/4.x/d9/d61/tutorial_py_morphological_ops.html\n",
    "\n",
    "The paper and video we're basing everythign off of:\n",
    "\n",
    "https://link.springer.com/article/10.1007/s11042-013-1501-1\n",
    "\n",
    "https://www.youtube.com/watch?v=xML2S6bvMwI"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "import math\n",
    "\n",
    "# bullet = cv2.imread(\"470-FingerGunGame/images/small_bullet3.png\")\n",
    "\n",
    "def superimpose(img_1, img_2):\n",
    "    img_1_gs = cv2.cvtColor(img_1, cv2.COLOR_BGR2GRAY)\n",
    "    _ret, mask = cv2.threshold(img_1_gs, 10, 255, cv2.THRESH_BINARY)\n",
    "    mask_inv = cv2.bitwise_not(mask)\n",
    "    roi = cv2.bitwise_and(img_1, img_1, mask=mask)\n",
    "    im2 = cv2.bitwise_and(img_2, img_2, mask=mask_inv)\n",
    "    result = cv2.add(im2, roi)\n",
    "    return result\n",
    "\n",
    "# top_left is the point where the top left of overlay_img should line up\n",
    "# top_right is the point where the top right of overlay_img should line up\n",
    "# both are in the background_img coordinate space\n",
    "def rotate_overlay_onto_line(overlay_img, background_img, top_left, top_right, top_offset = 0, left_offset = 0, right_offset = 0, flipped=False):\n",
    "\n",
    "    overlay_h, overlay_w = overlay_img.shape[:2]\n",
    "    background_h, background_w = background_img.shape[:2]\n",
    "\n",
    "    # ratio to scale up the overlay img by\n",
    "    ratio = math.dist(top_left, top_right) / overlay_w\n",
    "    \n",
    "    # points needed for the affine transformation\n",
    "    # in order: top left, top right, bottom right\n",
    "    # needs to be x, y\n",
    "\n",
    "    # the offset will scale a bit in the bottom right depending the the width to keep proportions\n",
    "    offset_scale = (overlay_w + right_offset) / overlay_w\n",
    "    pts1 = np.float32([[0-left_offset, 0-top_offset], [overlay_w-right_offset, 0-top_offset], [overlay_w-right_offset, (overlay_h/offset_scale)-top_offset]])\n",
    "\n",
    "    # used to determine where the bottom right point should be\n",
    "    line_angle = np.arctan2(top_right[1] - top_left[1], top_right[0] - top_left[0])\n",
    "\n",
    "    x_offset = math.sin(line_angle) * overlay_h * ratio\n",
    "    y_offset = math.cos(line_angle) * overlay_h * ratio\n",
    "\n",
    "    if flipped:\n",
    "        bottom_right = [int(top_right[0] + x_offset), int(top_right[1] - y_offset)]\n",
    "    else:\n",
    "        bottom_right = [int(top_right[0] - x_offset), int(top_right[1] + y_offset)]\n",
    "\n",
    "    pts2 = np.float32([top_left, top_right, bottom_right])\n",
    "\n",
    "    # get the affine transformation matrix\n",
    "    M = cv2.getAffineTransform(pts1, pts2)\n",
    "\n",
    "    # apply the affine transform to the overlay image\n",
    "    warped_overlay = cv2.warpAffine(overlay_img, M, (background_w, background_h))\n",
    "\n",
    "    # superimpose onto the background\n",
    "    return superimpose(warped_overlay, background_img)\n",
    "\n",
    "\n",
    "def draw_target(img, center, radius, color, alt_color=[255, 255, 255], num_circles=3):\n",
    "    for circle in range(num_circles):\n",
    "\n",
    "        if circle % 2:\n",
    "            target_color = alt_color\n",
    "        else:\n",
    "            target_color = color\n",
    "\n",
    "        radius_multiplier = 1 - circle/num_circles\n",
    "\n",
    "        cv2.circle(img, center, int(radius_multiplier * radius), target_color, -1)\n",
    "\n",
    "\n",
    "# get the angle between ab and ac given a, b, c xy-points of a triangle\n",
    "# uses the law of cosines aka the cosine rule / formula\n",
    "def cos_rule(a, b, c):\n",
    "    # euclidian distance between points\n",
    "    ab = math.dist(a, b)\n",
    "    bc = math.dist(b, c)\n",
    "    ac = math.dist(a, c)\n",
    "\n",
    "    # using law of cosines to compute angle between ab and bc\n",
    "\n",
    "    angle_abac = math.degrees(math.acos((ab ** 2 + ac ** 2 - bc ** 2) / (2 * ab * ac)))\n",
    "    return angle_abac\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import math\n",
    "import cv2\n",
    "import random\n",
    "import time\n",
    "\n",
    "\n",
    "cap = cv2.VideoCapture(1)\n",
    "\n",
    "background = cv2.imread(\"images/image1.png\")\n",
    "gun = cv2.imread(\"images/revolver2.png\")\n",
    "# bullet = cv2.imread(\"small_bullet.png\", cv2.IMREAD_UNCHANGED)\n",
    "\n",
    "# skin colour numbers\n",
    "# y_min = 25 #64\n",
    "# y_max = 193\n",
    "# cr_min = 139 # 133\n",
    "# cr_max = 173\n",
    "# cb_min = 77\n",
    "# cb_max = 127\n",
    "\n",
    "y_min = 23\n",
    "y_max = 244\n",
    "cr_min = 145\n",
    "cr_max = 173\n",
    "cb_min = 77\n",
    "cb_max = 127\n",
    "\n",
    "\n",
    "debug_level = 0\n",
    "# 0 = nothing extra drawn\n",
    "# 1 = contours\n",
    "# 2 = hull\n",
    "# 3 = hull defects\n",
    "# 4 = thumb area\n",
    "# 5 = palm circle and biggest circle\n",
    "# 6 = pistol\n",
    "\n",
    "def fingerGunGame(debug_level=0):\n",
    "    # colors (B, G, R)\n",
    "    bullet_color = (0, 0, 0)\n",
    "    bullet_radius = 9\n",
    "\n",
    "    gun_flipped = False\n",
    "    gun_topl = None\n",
    "    gun_topr = None\n",
    "    fire_ready = False\n",
    "    bullets = []\n",
    "    next_bullet = None\n",
    "\n",
    "    shots_fired = 0\n",
    "    targets_hit = 0\n",
    "\n",
    "    bullet_speed = 9\n",
    "    exit_angle = None\n",
    "    start_game = False\n",
    "    gameFinished = False\n",
    "    score = 0\n",
    "\n",
    "    win_h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))\n",
    "    win_w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))\n",
    "\n",
    "    # resize the background overlay\n",
    "    background_scaled = cv2.resize(background, [win_w, win_h], interpolation=cv2.INTER_AREA)\n",
    "\n",
    "    centre1 = [random.randint(100,1000), random.randint(200,350)]\n",
    "    centre2 = [random.randint(100,1000), random.randint(450,700)]\n",
    "    centre3 = [random.randint(100,1000), random.randint(800,980)]\n",
    "    radius1 = random.randint(30,100)\n",
    "    radius2 = random.randint(30,100)\n",
    "    radius3 = random.randint(30,100)\n",
    "    start_time = 0\n",
    "\n",
    "    # how long the game should last in seconds\n",
    "    game_length = 20\n",
    "\n",
    "\n",
    "    while start_time >= 0:\n",
    "        _ret, img = cap.read()\n",
    "        drawing = np.zeros(img.shape, np.uint8)\n",
    "        #grey = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n",
    "        kernel_size = (35, 35)\n",
    "        \n",
    "        img_ycrcb = cv2.cvtColor(img, cv2.COLOR_BGR2YCrCb)\n",
    "        #blurred = cv2.GaussianBlur(grey, kernel_size, 0)\n",
    "        blurred = cv2.GaussianBlur(img_ycrcb, kernel_size, 0)\n",
    "\n",
    "        scale_factor = 4\n",
    "        if scale_factor != 1:\n",
    "            blurred = cv2.resize(blurred, [blurred.shape[1]//scale_factor, blurred.shape[0]//scale_factor], interpolation=cv2.INTER_AREA)\n",
    "        \n",
    "        # skin color segmentation\n",
    "        skin_ycrcb_mint = np.array([y_min, cr_min, cb_min], np.uint8)\n",
    "        skin_ycrcb_maxt = np.array([y_max, cr_max, cb_max], np.uint8)\n",
    "        thresholded = cv2.inRange(blurred, skin_ycrcb_mint, skin_ycrcb_maxt)\n",
    "        #_ret, thresholded = cv2.threshold(blurred, 127, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)\n",
    "        contours, _hierarchy = cv2.findContours(thresholded.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n",
    "        #contours, _hierarchy = cv2.findContours(thresholded.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)\n",
    "\n",
    "        # mix the background with the image\n",
    "        if (debug_level == 0):\n",
    "            img = cv2.addWeighted(img, 0.2, background_scaled, 0.8, 0)\n",
    "\n",
    "        # if no contours are detected, don't draw anything\n",
    "        if len(contours) != 0:\n",
    "            # this is the largest contour found, which helps eliminate noise and should be the hand\n",
    "            count1 = max(contours, key=lambda x: cv2.contourArea(x))\n",
    "\n",
    "            # drawing the biggest enclosing circle of the contour shape, used for gesture recognition\n",
    "            big_c, big_r = cv2.minEnclosingCircle(count1)\n",
    "            big_c = (int(big_c[0])*scale_factor, int(big_c[1])*scale_factor)\n",
    "\n",
    "            #if ((big_r*scale_factor) > (3.5* center_dist*scale_factor)):\n",
    "\n",
    "            if debug_level >= 5:\n",
    "                # center point\n",
    "                cv2.circle(img, big_c, 1, (255, 0, 0), -1)\n",
    "                # circle containing hand\n",
    "                cv2.circle(img, big_c, int(big_r)*scale_factor, (255, 0, 0), 3)\n",
    "\n",
    "\n",
    "            # center point\n",
    "            cv2.circle(drawing, big_c, 1, (255, 0, 0), -1)\n",
    "            # circle containing hand\n",
    "            cv2.circle(drawing, big_c, int(big_r)*scale_factor, (255, 0, 0), 3)\n",
    "            \n",
    "            x, y, w, h = cv2.boundingRect(count1)\n",
    "\n",
    "            # finding the palm center\n",
    "            center_pt = (0, 0)\n",
    "            center_dist = 0\n",
    "            for pt_x in range(x, x+w, 2):\n",
    "                for pt_y in range(y, y+h, 2):\n",
    "                    pt = (pt_x, pt_y)\n",
    "                    dist = cv2.pointPolygonTest(count1, pt, measureDist=True)\n",
    "                    if dist > center_dist:\n",
    "                        center_pt = (pt_x * scale_factor, pt_y * scale_factor)\n",
    "                        center_dist = dist\n",
    "                    #cv2.circle(img, pt, 1, (255, 0, 255), 1)\n",
    "                    #else:\n",
    "                    #    cv2.circle(img, pt, 1, (0, 0, 0), 1)\n",
    "            \n",
    "            # biggest circle in palm\n",
    "            if debug_level >= 5:\n",
    "                cv2.circle(img, center_pt, int(center_dist)*scale_factor, (255, 255, 0), 3)\n",
    "                # circle 3.5 * the radius\n",
    "                #cv2.circle(img, center_pt, int(center_dist*3.5)*scale_factor, (255, 255, 0), 2)\n",
    "                # biggest circle / 2\n",
    "                #cv2.circle(img, center_pt, int(center_dist//2)*scale_factor, (0, 165, 255), 2)\n",
    "                # center of biggest circle\n",
    "                cv2.circle(img, center_pt, 1, (255, 255, 0), -1)\n",
    "            \n",
    "            cv2.circle(drawing, center_pt, int(center_dist)*scale_factor, (255, 255, 0), 3)\n",
    "            # circle 3.5 * the radius\n",
    "            #cv2.circle(img, center_pt, int(center_dist*3.5)*scale_factor, (255, 255, 0), 2)\n",
    "            # biggest circle / 2\n",
    "            #cv2.circle(drawing, center_pt, int(center_dist//2)*scale_factor, (0, 165, 255), 2)\n",
    "            # center of biggest circle\n",
    "            cv2.circle(drawing, center_pt, 1, (255, 255, 0), -1)\n",
    "\n",
    "            # not necessary at the moment\n",
    "            # rotRect = cv2.minAreaRect(count1)\n",
    "            # box = cv2.boxPoints(rotRect)\n",
    "            # box = np.int64(box)\n",
    "            # cv2.drawContours(img, [box*scale_factor], 0, (255, 255, 0), 1)\n",
    "\n",
    "            #cv2.rectangle(img, (x*scale_factor, y*scale_factor), ((x + w)*scale_factor, (y + h)*scale_factor), (0, 0, 255), 1)\n",
    "\n",
    "            #hull = cv2.convexHull(count1)\n",
    "            try:\n",
    "                hull = cv2.convexHull(count1, returnPoints=False)\n",
    "                defects = cv2.convexityDefects(count1, hull)\n",
    "            except:\n",
    "                # print(hull, count1)\n",
    "                continue\n",
    "                raise IOError(\"Hull issue\")\n",
    "            \n",
    "            # drawing contours\n",
    "            if debug_level >= 1:\n",
    "                cv2.drawContours(img, [count1*scale_factor], 0, (0, 255, 0), 0)\n",
    "\n",
    "\n",
    "            cv2.drawContours(drawing, [count1*scale_factor], 0, (0, 255, 0), 0)\n",
    "            #cv2.drawContours(drawing, [hull*scale_factor], 0, (0, 0, 255), 0)\n",
    "            count_defects = 0\n",
    "            #cv2.drawContours(thresholded, contours*scale_factor, -1, (0, 255, 0), 3)\n",
    "            \n",
    "\n",
    "            # doing contour extractions once again within the 3.5x circle\n",
    "            # grey = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n",
    "            # blurred2 = cv2.GaussianBlur(grey, kernel_size, 0)\n",
    "            # _ret, thresholded2 = cv2.threshold(blurred2, 127, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)\n",
    "            # contours2, _hierarchy = cv2.findContours(thresholded2.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)#cv2.CHAIN_APPROX_NONE)\n",
    "\n",
    "            # if len(contours2) != 0:\n",
    "            #     count1_2 = max(contours2, key=lambda x: cv2.contourArea(x))\n",
    "\n",
    "\n",
    "            # print(len(contours), defects.shape, '\\n\\n', contours)\n",
    "            # break\n",
    "\n",
    "            # go through all the defects in the hull\n",
    "            if defects is not None:\n",
    "                finger_tips = []\n",
    "                finger_valleys = []\n",
    "                angles = []\n",
    "                thumb_defect = None\n",
    "                biggest_angle = 0\n",
    "                for defect in defects:\n",
    "                    # start index, end index, farthest pt index, depth\n",
    "                    s, e, f, d = defect[0]\n",
    "                    start = tuple(count1[s][0])\n",
    "                    end = tuple(count1[e][0])\n",
    "                    far = tuple(count1[f][0])\n",
    "\n",
    "\n",
    "                    if debug_level >= 2:\n",
    "                        # draw a line from the start to the end to show the hull\n",
    "                        cv2.line(img, (start[0]*scale_factor, start[1]*scale_factor), (end[0]*scale_factor, end[1]*scale_factor), [0, 0, 255], 2)\n",
    "                    \n",
    "                    cv2.line(drawing, (start[0]*scale_factor, start[1]*scale_factor), (end[0]*scale_factor, end[1]*scale_factor), [0, 0, 255], 2)\n",
    "\n",
    "                    # depth has 8 fractional bits, to get the value as a float divide by 256\n",
    "                    depth = d // 256\n",
    "\n",
    "                    angle = cos_rule(far, start, end)\n",
    "\n",
    "                    # cosidered a finger when the angle is < 90º and depth of defect is between the small and large radius\n",
    "                    if angle <= 100 and depth > center_dist and depth < big_r:\n",
    "\n",
    "                        count_defects += 1\n",
    "                        finger_tips.append([s, e, f, d])\n",
    "                        angles.append(angle)\n",
    "                        max(contours, key=lambda x: cv2.contourArea(x))\n",
    "\n",
    "                        if angle > biggest_angle:\n",
    "                            biggest_angle = angle\n",
    "                            thumb_defect = [start, end, far]\n",
    "\n",
    "                        if debug_level >= 3:\n",
    "                            # draw circles at each of the start, far, and end points\n",
    "                            cv2.circle(img, (start[0]*scale_factor, start[1]*scale_factor), 3, [255, 0, 255], 3)\n",
    "                            cv2.circle(img, (end[0]*scale_factor, end[1]*scale_factor), 3, [255, 0, 255], 3)\n",
    "                            cv2.circle(img, (far[0]*scale_factor, far[1]*scale_factor), 3, [255, 0, 255], 3)\n",
    "                        \n",
    "                        cv2.circle(drawing, (start[0]*scale_factor, start[1]*scale_factor), 3, [255, 0, 255], 3)\n",
    "                        cv2.circle(drawing, (end[0]*scale_factor, end[1]*scale_factor), 3, [255, 0, 255], 3)\n",
    "                        cv2.circle(drawing, (far[0]*scale_factor, far[1]*scale_factor), 3, [255, 0, 255], 3)\n",
    "                        #print(f\"defect {count_defects}: start: {start}, end: {end}, far: {far}, ra: {int(center_dist)}, l: {depth}, rb: {int(big_r)}\")\n",
    "\n",
    "                # for a in range(len(angles)):\n",
    "                biggest_area = 0\n",
    "                thumb = None\n",
    "\n",
    "                for finger_tip in finger_tips:\n",
    "                    # start, end, far indices of the contour\n",
    "                    s, e, f, _d = finger_tip\n",
    "\n",
    "                    # check that the far point y is not above the thumb tip (aka it accidentally thinks the pinkie knuckle is the thumb tip)\n",
    "                    start = count1[s][0]\n",
    "                    end = count1[e][0]\n",
    "                    far = count1[f][0]\n",
    "\n",
    "                    tip_1 = math.dist(start, far)\n",
    "                    tip_2 = math.dist(end, far)\n",
    "\n",
    "                    if (tip_1 > tip_2):\n",
    "                        thumb_tip = end\n",
    "                    else:\n",
    "                        thumb_tip = start\n",
    "                    \n",
    "                    area = cv2.contourArea(count1[s:e+1])\n",
    "                    if thumb_tip[1] < far[1] and area > biggest_area:\n",
    "                        biggest_area = area\n",
    "                        thumb = finger_tip\n",
    "                    #biggest_area = max(finger_tips, key=lambda x: cv2.contourArea(count1[x[0]:x[1]+1]))\n",
    "                \n",
    "                if thumb is not None and start_game:\n",
    "                    s, e, f, _d = thumb\n",
    "                    count1_reshaped = count1.reshape(-1, 2)\n",
    "\n",
    "                    if debug_level >= 4:\n",
    "                        # filling the area between the thumb and pointer finger with blue to visually confirm the gun is working\n",
    "                        cv2.fillPoly(img, [count1_reshaped[s:e+1]*scale_factor], (255, 0, 0))\n",
    "\n",
    "                    cv2.fillPoly(drawing, [count1_reshaped[s:e+1]*scale_factor], (255, 0, 0))\n",
    "                    \n",
    "                    start = count1[s][0]\n",
    "                    end = count1[e][0]\n",
    "                    far = count1[f][0]\n",
    "                    angle = cos_rule(far, start, end)\n",
    "\n",
    "                    tip_1 = math.dist(start, far)\n",
    "                    tip_2 = math.dist(end, far)\n",
    "\n",
    "                    if (tip_1 > tip_2):\n",
    "                        pointer_tip = start\n",
    "                        thumb_tip = end\n",
    "                    else:\n",
    "                        pointer_tip = end\n",
    "                        thumb_tip = start\n",
    "\n",
    "                    # the line along the top of the pointer finger\n",
    "                    if (debug_level >= 3):\n",
    "                        cv2.line(img, pointer_tip*scale_factor, far*scale_factor, (255, 0, 255), 2)\n",
    "                        cv2.line(img, thumb_tip*scale_factor, far*scale_factor, (255, 0, 255), 2)\n",
    "\n",
    "                    cv2.line(drawing, pointer_tip*scale_factor, far*scale_factor, (255, 0, 255), 2)\n",
    "                    cv2.line(drawing, thumb_tip*scale_factor, far*scale_factor, (255, 0, 255), 2)\n",
    "\n",
    "                    gun_topl = pointer_tip*scale_factor\n",
    "                    gun_topr = far*scale_factor\n",
    "\n",
    "                    # set the flipped flag\n",
    "                    if gun_topl[0] > gun_topr[0]:\n",
    "                        gun_flipped = True\n",
    "                    else:\n",
    "                        gun_flipped = False\n",
    "\n",
    "                    # if angle < 80:\n",
    "                    #     fire_ready = False\n",
    "                    # else:\n",
    "                    #cv2.putText(img, f\"Angle: {angle:3.0f} - aim\", (1000, 50), cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 0, 0), 2)\n",
    "                    fire_ready = True\n",
    "                    next_bullet = pointer_tip\n",
    "\n",
    "                    x_dist = pointer_tip[0] - far[0]\n",
    "                    y_dist = pointer_tip[1] - far[1]\n",
    "                    exit_angle = math.atan2(y_dist, x_dist)\n",
    "\n",
    "            if fire_ready and count_defects == 0:\n",
    "                # cv2.putText(img, f\"Fire!\", (1000, 50), cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 0, 0), 4)\n",
    "                fire_ready = False\n",
    "\n",
    "                if next_bullet is not None:\n",
    "                    shots_fired += 1\n",
    "                    bullets.append([next_bullet, exit_angle])\n",
    "\n",
    "                    next_x = next_bullet[0] + math.cos(exit_angle) * bullet_speed\n",
    "                    next_y = next_bullet[1] + math.sin(exit_angle) * bullet_speed\n",
    "                    next_coords = (next_x, next_y)\n",
    "                    #print(f\"bullet_coords: {next_bullet}, angle: {math.degrees(exit_angle)}, next_coords: {next_coords}\")\n",
    "\n",
    "            #if count_defects < 5:\n",
    "            #    cv2.putText(img, f\"{count_defects+1} finger(s)\", (50, win_h - 100), cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 0, 0), 4)\n",
    "                \n",
    "            if not start_game and count_defects == 4:\n",
    "                start_game = True\n",
    "                start_time = time.time()\n",
    "\n",
    "        new_bullets = []\n",
    "\n",
    "        # draw the targets\n",
    "        draw_target(img, centre1, radius1, [255, 0, 0])\n",
    "        draw_target(img, centre2, radius2, [0, 255, 0])\n",
    "        draw_target(img, centre3, radius3, [0, 0, 255])\n",
    "\n",
    "        if gameFinished == False:\n",
    "            for b in range(len(bullets)):\n",
    "\n",
    "                bullet_coord, bullet_angle = bullets[b]\n",
    "                #print(bullet_coord)\n",
    "                # target 1 collision detection\n",
    "                if (math.dist(bullet_coord*scale_factor, centre1) <= radius1 + bullet_radius):\n",
    "                    targets_hit += 1\n",
    "                    # print(\"HIT\")\n",
    "                    if 30<=radius1<50:\n",
    "                        score+= 15\n",
    "                        # cv2.putText(img, f\"+15\", centre1, cv2.FONT_HERSHEY_SIMPLEX, 2, (19, 41, 1), 4)\n",
    "                        # cv2.waitKey(200)\n",
    "                    elif 50<=radius1<80:\n",
    "                        score+= 10\n",
    "                        # cv2.putText(img, f\"+10\", centre1, cv2.FONT_HERSHEY_SIMPLEX, 2, (19, 41, 1), 4)\n",
    "                        # cv2.waitKey(200)\n",
    "                    elif 80<= radius1 < 100:\n",
    "                        score+=5\n",
    "                        # cv2.putText(img, f\"+5\", centre1, cv2.FONT_HERSHEY_SIMPLEX, 2, (19, 41, 1), 4)\n",
    "                        # cv2.waitKey(200)\n",
    "                    radius1 = random.randint(30,100)\n",
    "                    centre1 = [random.randint(100,1000), random.randint(200,350)]\n",
    "                    continue\n",
    "\n",
    "            # target 2 collision detection\n",
    "                elif (math.dist(bullet_coord*scale_factor, centre2) <= radius2 + bullet_radius):\n",
    "                    targets_hit += 1\n",
    "                    # print(\"HIT\")\n",
    "                    if 30<=radius2<50:\n",
    "                        score+= 15\n",
    "                        # cv2.putText(img, f\"+15\", centre2, cv2.FONT_HERSHEY_SIMPLEX, 2, (19, 41, 1), 4)\n",
    "                        # cv2.waitKey(200)\n",
    "                    elif 50<=radius2<80:\n",
    "                        score+= 10\n",
    "                        # cv2.putText(img, f\"+10\", centre2, cv2.FONT_HERSHEY_SIMPLEX, 2, (19, 41, 1), 4)\n",
    "                        # cv2.waitKey(200)\n",
    "                    elif 80<= radius2 < 100:\n",
    "                        score+=5\n",
    "                        # cv2.putText(img, f\"+5\", centre2, cv2.FONT_HERSHEY_SIMPLEX, 2, (19, 41, 1), 4)\n",
    "                        # cv2.waitKey(200)\n",
    "                    radius2 = random.randint(30,100)\n",
    "                    centre2 = [random.randint(100,1000), random.randint(450,700)]\n",
    "                    continue\n",
    "\n",
    "                # target 3 collision detection\n",
    "                elif (math.dist(bullet_coord*scale_factor, centre3) <= radius3 + bullet_radius):\n",
    "                    targets_hit += 1\n",
    "                    # print(\"HIT\")\n",
    "                    if 30<=radius3<50:\n",
    "                        score+= 15\n",
    "                        # cv2.putText(img, f\"+15\", centre3, cv2.FONT_HERSHEY_SIMPLEX, 2, (19, 41, 1), 4)\n",
    "                        # cv2.waitKey(200)\n",
    "                    elif 50<=radius3<80:\n",
    "                        score+= 10\n",
    "                        # cv2.putText(img, f\"+10\", centre3, cv2.FONT_HERSHEY_SIMPLEX, 2, (19, 41, 1), 4)\n",
    "                        # cv2.waitKey(200)\n",
    "                    elif 80<= radius3 < 100:\n",
    "                        score+=5\n",
    "                        # cv2.putText(img, f\"+5\", centre3, cv2.FONT_HERSHEY_SIMPLEX, 2, (19, 41, 1), 4)\n",
    "                        # cv2.waitKey(200)\n",
    "\n",
    "                    radius3 = random.randint(30,100)\n",
    "                    centre3 = [random.randint(100,1000), random.randint(800,980)]\n",
    "                    continue\n",
    "\n",
    "                # get rid of any bullets not within the screen\n",
    "                if bullet_coord[0] > 0 and bullet_coord[0] < img.shape[1] and bullet_coord[1] > 0 and bullet_coord[1] < img.shape[0]:\n",
    "                    cv2.circle(img, bullet_coord*scale_factor, bullet_radius, bullet_color, -1)\n",
    "                    cv2.circle(drawing, bullet_coord*scale_factor, bullet_radius, [255, 255, 255], -1)\n",
    "\n",
    "                    # update the bullet location for the next frame\n",
    "                    bullet_coord[0] += math.cos(bullet_angle) * bullet_speed\n",
    "                    bullet_coord[1] += math.sin(bullet_angle) * bullet_speed\n",
    "                    new_bullets.append([bullet_coord, bullet_angle])\n",
    "\n",
    "        bullets = new_bullets\n",
    "\n",
    "        \n",
    "        if start_game:\n",
    "\n",
    "            if (not gameFinished and gun_topl is not None and (debug_level == 0 or debug_level == 6)):\n",
    "                img = rotate_overlay_onto_line(gun, img, gun_topl, gun_topr, top_offset=-20, right_offset=60, flipped=gun_flipped)\n",
    "\n",
    "            elapsed_time = time.time() - start_time\n",
    "            time_left = game_length - elapsed_time\n",
    "            if gameFinished or time_left <= 0:\n",
    "                gameFinished = True\n",
    "                img = background_scaled\n",
    "                cv2.putText(img, \"Finished!\", (830, 400), cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 0, 0), 6)\n",
    "                cv2.putText(img, f\"Score: {score}\", (830, 520), cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 0, 0), 6)\n",
    "                if shots_fired == 0:\n",
    "                    shots_fired = 1\n",
    "                accuracy = (targets_hit / shots_fired) * 100\n",
    "                cv2.putText(img, f\"Accuracy: {accuracy:.0f}%\", (750, 640), cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 0, 0), 6)\n",
    "                cv2.putText(img, \"Press Enter to play again\", (780, 800), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 4)\n",
    "                cv2.putText(img, \"Press Esc to quit\", (780, 870), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 4)\n",
    "\n",
    "            elif time_left <= 5:\n",
    "                cv2.putText(img, f\"Time: {time_left:.2f}\", (600, 100), cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 0, 100), 4)\n",
    "            else:\n",
    "                cv2.putText(img, f\"Time: {time_left:.2f}\", (600, 100), cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 0, 0), 4)\n",
    "\n",
    "            if not gameFinished:\n",
    "                cv2.putText(img, f\"Score: {score:4}\", (50, 100), cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 0, 0), 4)\n",
    "                cv2.putText(img, \"game started\", (win_w - 500, 100), cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 100, 0), 4)\n",
    "\n",
    "        else:\n",
    "            cv2.putText(img, \"waiting\", (win_w - 300, 100), cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 0, 180), 4)\n",
    "\n",
    "        all_img = np.vstack((img, drawing))\n",
    "\n",
    "        cv2.imshow('Finger Guns ', all_img)\n",
    "\n",
    "        if gameFinished:\n",
    "            return 0\n",
    "\n",
    "        k = cv2.waitKey(1)\n",
    "        if k == 27: # esc\n",
    "            return 1\n",
    "        elif k == 2: # left arrow\n",
    "            debug_level = max(0, debug_level - 1)\n",
    "        elif k == 3: # right arrow\n",
    "            debug_level = min(6, debug_level + 1)\n",
    "\n",
    "\n",
    "while 1:\n",
    "    retval = fingerGunGame(debug_level)\n",
    "\n",
    "    if retval:\n",
    "        break\n",
    "\n",
    "    k = cv2.waitKey(0)\n",
    "    if k == 27:\n",
    "        break\n",
    "\n",
    "cv2.destroyAllWindows()\n",
    "cv2.waitKey(1)\n",
    "cap.release()\n"
   ]
  }
 ],
 "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.10.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}