hillclimb.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-04-09 15:12:33.511621: I tensorflow/core/util/port.cc:110] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
      "2023-04-09 15:12:33.612519: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
      "2023-04-09 15:12:33.827962: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
      "2023-04-09 15:12:33.829027: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2023-04-09 15:12:36.245902: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n"
     ]
    }
   ],
   "source": [
    "import cv2\n",
    "import pyautogui\n",
    "from time import time\n",
    "from math import hypot\n",
    "import mediapipe as mp\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize mediapipe pose class.\n",
    "mp_pose = mp.solutions.pose\n",
    "\n",
    "# Setup the Pose function for images.\n",
    "pose_image = mp_pose.Pose(static_image_mode=True, min_detection_confidence=0.5, model_complexity=1)\n",
    "\n",
    "# Setup the Pose function for videos.\n",
    "pose_video = mp_pose.Pose(static_image_mode=False, model_complexity=1, min_detection_confidence=0.7,\n",
    "                          min_tracking_confidence=0.7)\n",
    "\n",
    "# Initialize mediapipe drawing class.\n",
    "mp_drawing = mp.solutions.drawing_utils "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def detectPose(image, pose, draw=False, display=False):\n",
    "    '''\n",
    "    This function performs the pose detection on the most prominent person in an image.\n",
    "    Args:\n",
    "        image:   The input image with a prominent person whose pose landmarks needs to be detected.\n",
    "        pose:    The pose function required to perform the pose detection.\n",
    "        draw:    A boolean value that is if set to true the function draw pose landmarks on the output image. \n",
    "        display: A boolean value that is if set to true the function displays the original input image, and the \n",
    "                 resultant image and returns nothing.\n",
    "    Returns:\n",
    "        output_image: The input image with the detected pose landmarks drawn if it was specified.\n",
    "        results:      The output of the pose landmarks detection on the input image.\n",
    "    '''\n",
    "    \n",
    "    # Create a copy of the input image.\n",
    "    output_image = image.copy()\n",
    "    \n",
    "    # Convert the image from BGR into RGB format.\n",
    "    imageRGB = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
    "    \n",
    "    # Perform the Pose Detection.\n",
    "    results = pose.process(imageRGB)\n",
    "    \n",
    "    # Check if any landmarks are detected and are specified to be drawn.\n",
    "    if results.pose_landmarks and draw:\n",
    "    \n",
    "        # Draw Pose Landmarks on the output image.\n",
    "        mp_drawing.draw_landmarks(image=output_image, landmark_list=results.pose_landmarks,\n",
    "                                  connections=mp_pose.POSE_CONNECTIONS,\n",
    "                                  landmark_drawing_spec=mp_drawing.DrawingSpec(color=(255,255,255),\n",
    "                                                                               thickness=3, circle_radius=3),\n",
    "                                  connection_drawing_spec=mp_drawing.DrawingSpec(color=(49,125,237),\n",
    "                                                                               thickness=2, circle_radius=2))\n",
    "\n",
    "    # Check if the original input image and the resultant image are specified to be displayed.\n",
    "    if display:\n",
    "    \n",
    "        # Display the original input image and the resultant image.\n",
    "        plt.figure(figsize=[22,22])\n",
    "        plt.subplot(121);plt.imshow(image[:,:,::-1]);plt.title(\"Original Image\");plt.axis('off');\n",
    "        plt.subplot(122);plt.imshow(output_image[:,:,::-1]);plt.title(\"Output Image\");plt.axis('off');\n",
    "        \n",
    "    # Otherwise\n",
    "    else:\n",
    "\n",
    "        # Return the output image and the results of pose landmarks detection.\n",
    "        return output_image, results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def checkHandsJoined(image, results, draw=False, display=False):\n",
    "    '''\n",
    "    This function checks whether the hands of the person are joined or not in an image.\n",
    "    Args:\n",
    "        image:   The input image with a prominent person whose hands status (joined or not) needs to be classified.\n",
    "        results: The output of the pose landmarks detection on the input image.\n",
    "        draw:    A boolean value that is if set to true the function writes the hands status & distance on the output image. \n",
    "        display: A boolean value that is if set to true the function displays the resultant image and returns nothing.\n",
    "    Returns:\n",
    "        output_image: The same input image but with the classified hands status written, if it was specified.\n",
    "        hand_status:  The classified status of the hands whether they are joined or not.\n",
    "    '''\n",
    "    \n",
    "    # Get the height and width of the input image.\n",
    "    height, width, _ = image.shape\n",
    "    \n",
    "    # Create a copy of the input image to write the hands status label on.\n",
    "    output_image = image.copy()\n",
    "    \n",
    "    # Get the left wrist landmark x and y coordinates.\n",
    "    left_wrist_landmark = (results.pose_landmarks.landmark[mp_pose.PoseLandmark.LEFT_WRIST].x * width,\n",
    "                          results.pose_landmarks.landmark[mp_pose.PoseLandmark.LEFT_WRIST].y * height)\n",
    "\n",
    "    # Get the right wrist landmark x and y coordinates.\n",
    "    right_wrist_landmark = (results.pose_landmarks.landmark[mp_pose.PoseLandmark.RIGHT_WRIST].x * width,\n",
    "                           results.pose_landmarks.landmark[mp_pose.PoseLandmark.RIGHT_WRIST].y * height)\n",
    "    \n",
    "    # Calculate the euclidean distance between the left and right wrist.\n",
    "    euclidean_distance = int(hypot(left_wrist_landmark[0] - right_wrist_landmark[0],\n",
    "                                   left_wrist_landmark[1] - right_wrist_landmark[1]))\n",
    "    \n",
    "    # Compare the distance between the wrists with a appropriate threshold to check if both hands are joined.\n",
    "    if euclidean_distance < 175:\n",
    "        \n",
    "        # Set the hands status to joined.\n",
    "        hand_status = 'Hands Joined'\n",
    "        \n",
    "        # Set the color value to green.\n",
    "        color = (0, 255, 0)\n",
    "        \n",
    "    # Otherwise.    \n",
    "    else:\n",
    "        \n",
    "        # Set the hands status to not joined.\n",
    "        hand_status = 'Hands Not Joined'\n",
    "        \n",
    "        # Set the color value to red.\n",
    "        color = (0, 0, 255)\n",
    "        \n",
    "    # Check if the Hands Joined status and hands distance are specified to be written on the output image.\n",
    "    if draw:\n",
    "\n",
    "        # Write the classified hands status on the image. \n",
    "        cv2.putText(output_image, hand_status, (10, 30), cv2.FONT_HERSHEY_PLAIN, 2, color, 3)\n",
    "        \n",
    "        # Write the the distance between the wrists on the image. \n",
    "        cv2.putText(output_image, f'Distance: {euclidean_distance}', (10, 70),\n",
    "                    cv2.FONT_HERSHEY_PLAIN, 2, color, 3)\n",
    "        \n",
    "    # Check if the output image is specified to be displayed.\n",
    "    if display:\n",
    "\n",
    "        # Display the output image.\n",
    "        plt.figure(figsize=[10,10])\n",
    "        plt.imshow(output_image[:,:,::-1]);plt.title(\"Output Image\");plt.axis('off');\n",
    "    \n",
    "    # Otherwise\n",
    "    else:\n",
    "    \n",
    "        # Return the output image and the classified hands status indicating whether the hands are joined or not.\n",
    "        return output_image, hand_status"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Warning: Ignoring XDG_SESSION_TYPE=wayland on Gnome. Use QT_QPA_PLATFORM=wayland to run on Wayland anyway.\n"
     ]
    }
   ],
   "source": [
    "# Initialize the VideoCapture object to read from the webcam.\n",
    "camera_video = cv2.VideoCapture(0)\n",
    "camera_video.set(3,1280)\n",
    "camera_video.set(4,960)\n",
    "\n",
    "# Create named window for resizing purposes.\n",
    "cv2.namedWindow('Hands Joined?', cv2.WINDOW_NORMAL)\n",
    "\n",
    "# Iterate until the webcam is accessed successfully.\n",
    "while camera_video.isOpened():\n",
    "    \n",
    "    # Read a frame.\n",
    "    ok, frame = camera_video.read()\n",
    "    \n",
    "    # Check if frame is not read properly then continue to the next iteration to read the next frame.\n",
    "    if not ok:\n",
    "        continue\n",
    "    \n",
    "    # Flip the frame horizontally for natural (selfie-view) visualization.\n",
    "    frame = cv2.flip(frame, 1)\n",
    "    \n",
    "    # Get the height and width of the frame of the webcam video.\n",
    "    frame_height, frame_width, _ = frame.shape\n",
    "    \n",
    "    # Perform the pose detection on the frame.\n",
    "    frame, results = detectPose(frame, pose_video, draw=True)\n",
    "    \n",
    "    # Check if the pose landmarks in the frame are detected.\n",
    "    if results.pose_landmarks:\n",
    "            \n",
    "        # Check if the left and right hands are joined.\n",
    "        frame, _ = checkHandsJoined(frame, results, draw=True)\n",
    "                \n",
    "    # Display the frame.\n",
    "    cv2.imshow('Hands Joined?', frame)\n",
    "    \n",
    "    # Wait for 1ms. If a key is pressed, retreive the ASCII code of the key.\n",
    "    k = cv2.waitKey(1) & 0xFF\n",
    "    \n",
    "    # Check if 'ESC' is pressed and break the loop.\n",
    "    if(k == 27):\n",
    "        break\n",
    "\n",
    "# Release the VideoCapture Object and close the windows.\n",
    "camera_video.release()\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def checkLeftRight(image, results, draw=False, display=False):\n",
    "    '''\n",
    "    This function finds the horizontal position (left, center, right) of the person in an image.\n",
    "    Args:\n",
    "        image:   The input image with a prominent person whose the horizontal position needs to be found.\n",
    "        results: The output of the pose landmarks detection on the input image.\n",
    "        draw:    A boolean value that is if set to true the function writes the horizontal position on the output image. \n",
    "        display: A boolean value that is if set to true the function displays the resultant image and returns nothing.\n",
    "    Returns:\n",
    "        output_image:         The same input image but with the horizontal position written, if it was specified.\n",
    "        horizontal_position:  The horizontal position (left, center, right) of the person in the input image.\n",
    "    '''\n",
    "    \n",
    "    # Declare a variable to store the horizontal position (left, center, right) of the person.\n",
    "    horizontal_position = None\n",
    "    \n",
    "    # Get the height and width of the image.\n",
    "    height, width, _ = image.shape\n",
    "    \n",
    "    # Create a copy of the input image to write the horizontal position on.\n",
    "    output_image = image.copy()\n",
    "    \n",
    "    # Retreive the x-coordinate of the left shoulder landmark.\n",
    "    left_x = int(results.pose_landmarks.landmark[mp_pose.PoseLandmark.RIGHT_ANKLE].x * width)\n",
    "\n",
    "    # Retreive the x-corrdinate of the right shoulder landmark.\n",
    "    right_x = int(results.pose_landmarks.landmark[mp_pose.PoseLandmark.LEFT_ANKLE].x * width)\n",
    "    \n",
    "    # Check if the person is at left that is when both shoulder landmarks x-corrdinates\n",
    "    # are less than or equal to the x-corrdinate of the center of the image.\n",
    "    if (right_x <= width//2 and left_x <= width//2):\n",
    "        \n",
    "        # Set the person's position to left.\n",
    "        horizontal_position = 'Left'\n",
    "\n",
    "    # Check if the person is at right that is when both shoulder landmarks x-corrdinates\n",
    "    # are greater than or equal to the x-corrdinate of the center of the image.\n",
    "    elif (right_x >= width//2 and left_x >= width//2):\n",
    "        \n",
    "        # Set the person's position to right.\n",
    "        horizontal_position = 'Right'\n",
    "    \n",
    "    # Check if the person is at center that is when right shoulder landmark x-corrdinate is greater than or equal to\n",
    "    # and left shoulder landmark x-corrdinate is less than or equal to the x-corrdinate of the center of the image.\n",
    "    elif (right_x >= width//2 and left_x <= width//2):\n",
    "        \n",
    "        # Set the person's position to center.\n",
    "        horizontal_position = 'Center'\n",
    "        \n",
    "    # Check if the person's horizontal position and a line at the center of the image is specified to be drawn.\n",
    "    if draw:\n",
    "\n",
    "        # Write the horizontal position of the person on the image. \n",
    "        cv2.putText(output_image, horizontal_position, (5, height - 10), cv2.FONT_HERSHEY_PLAIN, 2, (255, 255, 255), 3)\n",
    "        \n",
    "        # Draw a line at the center of the image.\n",
    "        cv2.line(output_image, (width//2, 0), (width//2, height), (255, 255, 255), 2)\n",
    "        \n",
    "    # Check if the output image is specified to be displayed.\n",
    "    if display:\n",
    "\n",
    "        # Display the output image.\n",
    "        plt.figure(figsize=[10,10])\n",
    "        plt.imshow(output_image[:,:,::-1]);plt.title(\"Output Image\");plt.axis('off');\n",
    "    \n",
    "    # Otherwise\n",
    "    else:\n",
    "    \n",
    "        # Return the output image and the person's horizontal position.\n",
    "        return output_image, horizontal_position"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Warning: Ignoring XDG_SESSION_TYPE=wayland on Gnome. Use QT_QPA_PLATFORM=wayland to run on Wayland anyway.\n"
     ]
    }
   ],
   "source": [
    "# Initialize the VideoCapture object to read from the webcam.\n",
    "camera_video = cv2.VideoCapture(0)\n",
    "camera_video.set(3,1280)\n",
    "camera_video.set(4,960)\n",
    "\n",
    "# Create named window for resizing purposes.\n",
    "cv2.namedWindow('Horizontal Movements', cv2.WINDOW_NORMAL)\n",
    "\n",
    "# Iterate until the webcam is accessed successfully.\n",
    "while camera_video.isOpened():\n",
    "    \n",
    "    # Read a frame.\n",
    "    ok, frame = camera_video.read()\n",
    "    \n",
    "    # Check if frame is not read properly then continue to the next iteration to read the next frame.\n",
    "    if not ok:\n",
    "        continue\n",
    "    \n",
    "    # Flip the frame horizontally for natural (selfie-view) visualization.\n",
    "    frame = cv2.flip(frame, 1)\n",
    "    \n",
    "    # Get the height and width of the frame of the webcam video.\n",
    "    frame_height, frame_width, _ = frame.shape\n",
    "    \n",
    "    # Perform the pose detection on the frame.\n",
    "    frame, results = detectPose(frame, pose_video, draw=True)\n",
    "    \n",
    "    # Check if the pose landmarks in the frame are detected.\n",
    "    if results.pose_landmarks:\n",
    "            \n",
    "        # Check the horizontal position of the person in the frame.\n",
    "        frame, _ = checkLeftRight(frame, results, draw=True)\n",
    "                \n",
    "    # Display the frame.\n",
    "    cv2.imshow('Horizontal Movements', frame)\n",
    "    \n",
    "    # Wait for 1ms. If a a key is pressed, retreive the ASCII code of the key.\n",
    "    k = cv2.waitKey(1) & 0xFF\n",
    "    \n",
    "    # Check if 'ESC' is pressed and break the loop.\n",
    "    if(k == 27):\n",
    "        break\n",
    "\n",
    "# Release the VideoCapture Object and close the windows.\n",
    "camera_video.release()\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize the VideoCapture object to read from the webcam.\n",
    "camera_video = cv2.VideoCapture(0)\n",
    "camera_video.set(3,1280)\n",
    "camera_video.set(4,960)\n",
    "\n",
    "# Create named window for resizing purposes.\n",
    "cv2.namedWindow('HILL CLIMB WITH POSE DETECTION', cv2.WINDOW_NORMAL)\n",
    " \n",
    "# Initialize a variable to store the time of the previous frame.\n",
    "time1 = 0  \n",
    "\n",
    "# Initialize a variable to store the state of the game (started or not).\n",
    "game_started = False   \n",
    "\n",
    "# Initialize a variable to store the index of the current horizontal position of the person.\n",
    "# At Start the character is at center so the index is 1 and it can move left (value 0) and right (value 2).\n",
    "x_pos_index = 1\n",
    "\n",
    "# Initialize a variable to store the index of the current vertical posture of the person.\n",
    "# At Start the person is standing so the index is 1 and he can crouch (value 0) and jump (value 2).\n",
    "y_pos_index = 1\n",
    "\n",
    "# Declate a variable to store the intial y-coordinate of the mid-point of both shoulders of the person.\n",
    "MID_Y = None\n",
    "\n",
    "# Initialize a counter to store count of the number of consecutive frames with person's hands joined.\n",
    "counter = 0\n",
    "\n",
    "# Initialize the number of consecutive frames on which we want to check if person hands joined before starting the game.\n",
    "num_of_frames = 10\n",
    "\n",
    "# Iterate until the webcam is accessed successfully.\n",
    "while camera_video.isOpened():\n",
    "    \n",
    "    # Read a frame.\n",
    "    ok, frame = camera_video.read()\n",
    "    \n",
    "    # Check if frame is not read properly then continue to the next iteration to read the next frame.\n",
    "    if not ok:\n",
    "        continue\n",
    "    \n",
    "    # Flip the frame horizontally for natural (selfie-view) visualization.\n",
    "    frame = cv2.flip(frame, 1)\n",
    "    \n",
    "    # Get the height and width of the frame of the webcam video.\n",
    "    frame_height, frame_width, _ = frame.shape\n",
    "    \n",
    "    # Perform the pose detection on the frame.\n",
    "    frame, results = detectPose(frame, pose_video, draw=game_started)\n",
    "    \n",
    "    # Check if the pose landmarks in the frame are detected.\n",
    "    if results.pose_landmarks:\n",
    "        \n",
    "        # Check if the game has started\n",
    "        if game_started:\n",
    "            \n",
    "            # Commands to control the horizontal movements of the character.\n",
    "            #--------------------------------------------------------------------------------------------------------------\n",
    "            \n",
    "            # Get horizontal position of the person in the frame.\n",
    "            frame, horizontal_position = checkLeftRight(frame, results, draw=True)\n",
    "            \n",
    "            # Check if the person has moved to left from center or to center from right.\n",
    "            if (horizontal_position=='Left'):\n",
    "                \n",
    "                # Press the left arrow key.\n",
    "                pyautogui.keyUp('right')\n",
    "                pyautogui.keyDown('left')\n",
    "                \n",
    "                # Update the horizontal position index of the character.\n",
    "                x_pos_index -= 1               \n",
    "\n",
    "            # Check if the person has moved to Right from center or to center from left.\n",
    "            elif (horizontal_position=='Right'):\n",
    "                \n",
    "                # Press the right arrow key.\n",
    "                \n",
    "                pyautogui.keyUp('left')\n",
    "                pyautogui.keyDown('right')\n",
    "                \n",
    "                # Update the horizontal position index of the character.\n",
    "                x_pos_index += 1\n",
    "\n",
    "            else:\n",
    "                pyautogui.keyUp('right')\n",
    "                pyautogui.keyUp('left')\n",
    "            \n",
    "            #--------------------------------------------------------------------------------------------------------------\n",
    "        \n",
    "        # Otherwise if the game has not started    \n",
    "        else:\n",
    "            \n",
    "            # Write the text representing the way to start the game on the frame. \n",
    "            cv2.putText(frame, 'JOIN BOTH HANDS TO START THE GAME.', (5, frame_height - 10), cv2.FONT_HERSHEY_PLAIN,\n",
    "                        2, (0, 255, 0), 3)\n",
    "            \n",
    "            \n",
    "        \n",
    "        # Command to Start or resume the game.\n",
    "        #------------------------------------------------------------------------------------------------------------------\n",
    "        \n",
    "        # Check if the left and right hands are joined.\n",
    "        if checkHandsJoined(frame, results)[1] == 'Hands Joined':\n",
    "\n",
    "            # Increment the count of consecutive frames with +ve condition.\n",
    "            counter += 1\n",
    "\n",
    "            # Check if the counter is equal to the required number of consecutive frames.  \n",
    "            if counter == num_of_frames:\n",
    "\n",
    "                # Command to Start the game first time.\n",
    "                #----------------------------------------------------------------------------------------------------------\n",
    "                \n",
    "                # Check if the game has not started yet.\n",
    "                if not(game_started):\n",
    "\n",
    "                    # Update the value of the variable that stores the game state.\n",
    "                    game_started = True\n",
    "\n",
    "                    # Retreive the y-coordinate of the left shoulder landmark.\n",
    "                    left_y = int(results.pose_landmarks.landmark[mp_pose.PoseLandmark.RIGHT_SHOULDER].y * frame_height)\n",
    "\n",
    "                    # Retreive the y-coordinate of the right shoulder landmark.\n",
    "                    right_y = int(results.pose_landmarks.landmark[mp_pose.PoseLandmark.LEFT_SHOULDER].y * frame_height)\n",
    "\n",
    "                    # Calculate the intial y-coordinate of the mid-point of both shoulders of the person.\n",
    "                    MID_Y = abs(right_y + left_y) // 2\n",
    "\n",
    "                    # Move to 1300, 800, then click the left mouse button to start the game.\n",
    "                    pyautogui.click(x=1300, y=800, button='left')\n",
    "                \n",
    "                #----------------------------------------------------------------------------------------------------------\n",
    "\n",
    "                # Command to resume the game after death of the character.\n",
    "                #----------------------------------------------------------------------------------------------------------\n",
    "                \n",
    "                # Otherwise if the game has started.\n",
    "                else:\n",
    "\n",
    "                    # Press the space key.\n",
    "                    pyautogui.press('space')\n",
    "                \n",
    "                #----------------------------------------------------------------------------------------------------------\n",
    "                \n",
    "                # Update the counter value to zero.\n",
    "                counter = 0\n",
    "\n",
    "        # Otherwise if the left and right hands are not joined.        \n",
    "        else:\n",
    "\n",
    "            # Update the counter value to zero.\n",
    "            counter = 0\n",
    "            \n",
    "        #------------------------------------------------------------------------------------------------------------------\n",
    "\n",
    "        # Commands to control the vertical movements of the character.\n",
    "        #------------------------------------------------------------------------------------------------------------------\n",
    "        \n",
    "        # Check if the intial y-coordinate of the mid-point of both shoulders of the person has a value.\n",
    "        \n",
    "        #------------------------------------------------------------------------------------------------------------------\n",
    "    \n",
    "    \n",
    "    # Otherwise if the pose landmarks in the frame are not detected.       \n",
    "    else:\n",
    "\n",
    "        # Update the counter value to zero.\n",
    "        counter = 0\n",
    "        \n",
    "    # Calculate the frames updates in one second\n",
    "    #----------------------------------------------------------------------------------------------------------------------\n",
    "    \n",
    "    # Set the time for this frame to the current time.\n",
    "    time2 = time()\n",
    "    \n",
    "    # Check if the difference between the previous and this frame time > 0 to avoid division by zero.\n",
    "    if (time2 - time1) > 0:\n",
    "    \n",
    "        # Calculate the number of frames per second.\n",
    "        frames_per_second = 1.0 / (time2 - time1)\n",
    "        \n",
    "        # Write the calculated number of frames per second on the frame. \n",
    "        cv2.putText(frame, 'FPS: {}'.format(int(frames_per_second)), (10, 30),cv2.FONT_HERSHEY_PLAIN, 2, (0, 255, 0), 3)\n",
    "    \n",
    "    # Update the previous frame time to this frame time.\n",
    "    # As this frame will become previous frame in next iteration.\n",
    "    time1 = time2\n",
    "    \n",
    "    #----------------------------------------------------------------------------------------------------------------------\n",
    "    \n",
    "    # Display the frame.            \n",
    "    cv2.imshow('Hill CLimb with Pose Detection', frame)\n",
    "    \n",
    "    # Wait for 1ms. If a a key is pressed, retreive the ASCII code of the key.\n",
    "    k = cv2.waitKey(1) & 0xFF    \n",
    "    \n",
    "    # Check if 'ESC' is pressed and break the loop.\n",
    "    if(k == 27):\n",
    "        break\n",
    "\n",
    "# Release the VideoCapture Object and close the windows.                  \n",
    "camera_video.release()\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.11.2"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}