FingerCount.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "\n",
    "# Used for distance calculation later on\n",
    "from sklearn.metrics import pairwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "background = None\n",
    "accumulated_weight = 0.5\n",
    "\n",
    "# Manually set up our ROI for grabbing the hand.\n",
    "roi_top = 20\n",
    "roi_bottom = 300\n",
    "roi_right = 300\n",
    "roi_left = 600\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calc_accum_avg(frame, accumulated_weight):\n",
    "\n",
    "    \n",
    "    # Grab the background\n",
    "    global background\n",
    "    \n",
    "    # create the background from a copy of the frame.\n",
    "    if background is None:\n",
    "        background = frame.copy().astype(\"float\")\n",
    "        return None\n",
    "\n",
    "    # compute weighted average and update the background\n",
    "    cv2.accumulateWeighted(frame, background, accumulated_weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def segment(frame, threshold=25):\n",
    "    global background\n",
    "    \n",
    "    # Calculates the Absolute Differentce between the backgroud and the passed in frame\n",
    "    diff = cv2.absdiff(background.astype(\"uint8\"), frame)\n",
    "\n",
    "    # Apply a threshold to the image to grab the foreground\n",
    "    _ , thresholded = cv2.threshold(diff, threshold, 255, cv2.THRESH_BINARY)\n",
    "\n",
    "    # Grab the external contours form the image\n",
    "    image, contours, hierarchy = cv2.findContours(thresholded.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
    "\n",
    "    # If length of contours list is 0, then no any contours!\n",
    "    if len(contours) == 0:\n",
    "        return None\n",
    "    else:\n",
    "        # The largest external contour should be the hand (largest by area)\n",
    "        hand_segment = max(contours, key=cv2.contourArea)\n",
    "        \n",
    "        # Return both the hand segment and the thresholded hand image\n",
    "        return (thresholded, hand_segment)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_fingers(thresholded, hand_segment):\n",
    "    \n",
    "    \n",
    "    # Calculated the convex hull of the hand segment\n",
    "    conv_hull = cv2.convexHull(hand_segment)\n",
    "    \n",
    "\n",
    "\n",
    "    # Find the top, bottom, left , and right.\n",
    "    top    = tuple(conv_hull[conv_hull[:, :, 1].argmin()][0])\n",
    "    bottom = tuple(conv_hull[conv_hull[:, :, 1].argmax()][0])\n",
    "    left   = tuple(conv_hull[conv_hull[:, :, 0].argmin()][0])\n",
    "    right  = tuple(conv_hull[conv_hull[:, :, 0].argmax()][0])\n",
    "\n",
    "    # In theory, the center of the hand is half way between the top and bottom and halfway between left and right\n",
    "    cX = (left[0] + right[0]) // 2\n",
    "    cY = (top[1] + bottom[1]) // 2\n",
    "\n",
    "    # find the maximum euclidean distance between the center of the palm\n",
    "    \n",
    "    # Calculate the Euclidean Distance between the center of the hand and the left, right, top, and bottom.\n",
    "    distance = pairwise.euclidean_distances([(cX, cY)], Y=[left, right, top, bottom])[0]\n",
    "    \n",
    "    max_distance = distance.max()\n",
    "    \n",
    "    # Create a circle with 90% radius of the max euclidean distance\n",
    "    radius = int(0.8 * max_distance)\n",
    "    circumference = (2 * np.pi * radius)\n",
    "\n",
    "    # Not grab an ROI of only that circle\n",
    "    circular_roi = np.zeros(thresholded.shape[:2], dtype=\"uint8\")\n",
    "    \n",
    "\n",
    "    cv2.circle(circular_roi, (cX, cY), radius, 255, 10)\n",
    "    \n",
    "    \n",
    "    # Using bit-wise AND with the cirle ROI as a mask.\n",
    "    circular_roi = cv2.bitwise_and(thresholded, thresholded, mask=circular_roi)\n",
    "\n",
    "    # Grab contours in circle ROI\n",
    "    image, contours, hierarchy = cv2.findContours(circular_roi.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\n",
    "\n",
    "    # Finger count starts at 0\n",
    "    count = 0\n",
    "\n",
    "    for cnt in contours:\n",
    "        \n",
    "        # Bounding box of countour\n",
    "        (x, y, w, h) = cv2.boundingRect(cnt)\n",
    "        \n",
    "        #Contour region is not the very bottom of hand area (the wrist)\n",
    "        out_of_wrist = ((cY + (cY * 0.25)) > (y + h))\n",
    "        \n",
    "        #Number of points along the contour does not exceed 25% of the circumference of the circular ROI \n",
    "        limit_points = ((circumference * 0.25) > cnt.shape[0])\n",
    "        \n",
    "        \n",
    "        if  out_of_wrist and limit_points:\n",
    "            count += 1\n",
    "\n",
    "    return count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "cam = cv2.VideoCapture(0)\n",
    "\n",
    "\n",
    "num_frames = 0\n",
    "\n",
    "\n",
    "while True:\n",
    "    # get the current frame\n",
    "    ret, frame = cam.read()\n",
    "\n",
    "    # flip the frame so that it is not the mirror view\n",
    "    frame = cv2.flip(frame, 1)\n",
    "\n",
    "    # clone the frame\n",
    "    frame_copy = frame.copy()\n",
    "\n",
    "    # Grab the ROI from the frame\n",
    "    roi = frame[roi_top:roi_bottom, roi_right:roi_left]\n",
    "\n",
    "    # Apply grayscale and blur to ROI\n",
    "    gray = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY)\n",
    "    gray = cv2.GaussianBlur(gray, (7, 7), 0)\n",
    "\n",
    "    # For the first 30 frames, calculate the average of the background.\n",
    "    if num_frames < 60:\n",
    "        calc_accum_avg(gray, accumulated_weight)\n",
    "        if num_frames <= 59:\n",
    "            cv2.putText(frame_copy, \"WAIT! GETTING BACKGROUND AVG.\", (200, 400), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,255), 2)\n",
    "            cv2.imshow(\"Finger Count\",frame_copy)\n",
    "            \n",
    "    else:\n",
    "        \n",
    "        # segment the hand region\n",
    "        hand = segment(gray)\n",
    "\n",
    "        # Checking the hand is detected\n",
    "        if hand is not None:\n",
    "            \n",
    "            # unpack\n",
    "            thresholded, hand_segment = hand\n",
    "\n",
    "            # Draw contours around hand segment\n",
    "            cv2.drawContours(frame_copy, [hand_segment + (roi_right, roi_top)], -1, (255, 0, 0),1)\n",
    "\n",
    "            # Count the fingers\n",
    "            fingers = count_fingers(thresholded, hand_segment)\n",
    "\n",
    "            # Display count\n",
    "            cv2.putText(frame_copy, str(fingers), (70, 45), cv2.FONT_HERSHEY_SIMPLEX, 2, (0,0,255),5)\n",
    "\n",
    "            # Also display the thresholded image\n",
    "            cv2.imshow(\"Thesholded\", thresholded)\n",
    "\n",
    "    # Draw ROI Rectangle on frame copy\n",
    "    cv2.rectangle(frame_copy, (roi_left, roi_top), (roi_right, roi_bottom), (0,0,255), 5)\n",
    "\n",
    "    # increment the number of frames for tracking\n",
    "    num_frames += 1\n",
    "\n",
    "    # Display the frame with segmented hand\n",
    "    cv2.imshow(\"Finger Count\", frame_copy)\n",
    "\n",
    "\n",
    "    # Close windows with Esc\n",
    "    k = cv2.waitKey(1) & 0xFF\n",
    "\n",
    "    if k == 27:\n",
    "        break\n",
    "\n",
    "# Release the camera and destroy all the windows\n",
    "cam.release()\n",
    "cv2.destroyAllWindows()"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}