media pipe pose.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2 \n",
    "import mediapipe as mp\n",
    "import numpy as np\n",
    "mp_drawing = mp.solutions.drawing_utils # when visualing out poses\n",
    "mp_pose = mp.solutions.pose"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "cap = cv2.VideoCapture(0)\n",
    "## setup mediapipe instance\n",
    "with mp_pose.Pose(min_detection_confidence=0.5, min_tracking_confidence=0.5) as pose: #.Pose access pose estimation model, #min_tracking_confidence tracks state\n",
    "    while cap.isOpened():\n",
    "        ret, frame = cap.read() # frame is image from camera\n",
    "        \n",
    "        # Recolor image\n",
    "        image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n",
    "        image.flags.writeable = False # save memory\n",
    "        \n",
    "        # Make detection\n",
    "        results = pose.process(image) # image here is RGB\n",
    "        \n",
    "        # Recolor back to BGR\n",
    "        image.flags.writeable = True\n",
    "        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\n",
    "        \n",
    "        mp_drawing.draw_landmarks(image, results.pose_landmarks, mp_pose.POSE_CONNECTIONS,\n",
    "                                  mp_drawing.DrawingSpec(color=(245,117,66), thickness=2, circle_radius=2),\n",
    "                                  mp_drawing.DrawingSpec(color=(245,66,230), thickness=2, circle_radius=2)) # image here is BGR\n",
    "        \n",
    "        cv2.imshow('Mediappipe Feed', image)\n",
    "        \n",
    "        if cv2.waitKey(10) & 0xFF == ord('q'):\n",
    "            break\n",
    "\n",
    "    cap.release()\n",
    "    cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Determining Joints"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src = \"https://mediapipe.dev/images/mobile/pose_tracking_full_body_landmarks.png\" style=\"height:300px\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "cap = cv2.VideoCapture(0)\n",
    "## setup mediapipe instance\n",
    "with mp_pose.Pose(min_detection_confidence=0.5, min_tracking_confidence=0.5) as pose: #.Pose access pose estimation model, #min_tracking_confidence tracks state\n",
    "    while cap.isOpened():\n",
    "        ret, frame = cap.read() # frame is image from camera\n",
    "        \n",
    "        # Recolor image\n",
    "        image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n",
    "        image.flags.writeable = False # save memory\n",
    "        \n",
    "        # Make detection\n",
    "        results = pose.process(image) # image here is RGB\n",
    "        \n",
    "        # Recolor back to BGR\n",
    "        image.flags.writeable = True\n",
    "        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\n",
    "        \n",
    "        # Extract landmarks\n",
    "        try:\n",
    "            landmarks = results.pose_landmarks.landmark # hold landamrks. including x,y,z. Use this for calculating angles\n",
    "            # print(landmarks[mp_pose.PoseLandmark.LEFT_FOOT_INDEX])\n",
    "            # Filter out landmarks with low visibility\n",
    "        except:\n",
    "            pass\n",
    "        \n",
    "        mp_drawing.draw_landmarks(image, results.pose_landmarks, mp_pose.POSE_CONNECTIONS,\n",
    "                                  mp_drawing.DrawingSpec(color=(245,117,66), thickness=2, circle_radius=2),\n",
    "                                  mp_drawing.DrawingSpec(color=(245,66,230), thickness=2, circle_radius=2)) # image here is BGR\n",
    "        \n",
    "        cv2.imshow('Mediappipe Feed', image)\n",
    "        \n",
    "        if cv2.waitKey(10) & 0xFF == ord('q'):\n",
    "            break\n",
    "\n",
    "    cap.release()\n",
    "    cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculate Angles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "def calculate_angle(a,b,c):        \n",
    "    ## Using only x,y coordniates\n",
    "    a = np.array(a) # Frist\n",
    "    b = np.array(b) # Mid\n",
    "    c = np.array(c) # End\n",
    "    \n",
    "    radians = np.arctan2(c[1] - b[1], c[0] -b[0]) - np.arctan2(a[1]-b[1], a[0]-b[0])\n",
    "    angle = np.abs(radians * 180.0/np.pi)\n",
    "    \n",
    "    if angle > 180.0:\n",
    "        angle = 360 - angle\n",
    "        \n",
    "    return angle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "cap = cv2.VideoCapture(0)\n",
    "## setup mediapipe instance\n",
    "with mp_pose.Pose(min_detection_confidence=0.5, min_tracking_confidence=0.5) as pose: #.Pose access pose estimation model, #min_tracking_confidence tracks state\n",
    "    while cap.isOpened():\n",
    "        ret, frame = cap.read() # frame is image from camera\n",
    "        \n",
    "        # Recolor image\n",
    "        image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n",
    "        image.flags.writeable = False # save memory\n",
    "        \n",
    "        # Make detection\n",
    "        results = pose.process(image) # image here is RGB\n",
    "        \n",
    "        # Recolor back to BGR\n",
    "        image.flags.writeable = True\n",
    "        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\n",
    "        \n",
    "        # Extract landmarks\n",
    "        try:\n",
    "            landmarks = results.pose_landmarks.landmark # hold landamrks. including x,y,z. Use this for calculating angles\n",
    "\n",
    "            # Filter out landmarks with low visibility\n",
    "            shoulder = [landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].x, landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].y]\n",
    "            elbow = [landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].x, landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].y]\n",
    "            wrist = [landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].x, landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].y]    \n",
    "            \n",
    "            angle = calculate_angle(shoulder, elbow, wrist)\n",
    "            \n",
    "            # Visualizeq\n",
    "            cv2.putText(image, \n",
    "                        str(angle),\n",
    "                        tuple(np.multiply(elbow, [640, 480]).astype(int)), # controal [640, 480] to window size\n",
    "                        cv2.FONT_HERSHEY_SIMPLEX, 1, (255,255,255), 2)\n",
    "        except:\n",
    "            pass\n",
    "        \n",
    "        mp_drawing.draw_landmarks(image, results.pose_landmarks, mp_pose.POSE_CONNECTIONS,\n",
    "                                  mp_drawing.DrawingSpec(color=(245,117,66), thickness=2, circle_radius=2),\n",
    "                                  mp_drawing.DrawingSpec(color=(245,66,230), thickness=2, circle_radius=2)) # image here is BGR\n",
    "        \n",
    "        cv2.imshow('Mediappipe Feed', image)\n",
    "        \n",
    "        if cv2.waitKey(10) & 0xFF == ord('q'):\n",
    "            break\n",
    "\n",
    "    cap.release()\n",
    "    cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Curl Counter\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "cap = cv2.VideoCapture(0)\n",
    "\n",
    "## Curl counter variables\n",
    "counter = 0\n",
    "stage = None\n",
    "\n",
    "## setup mediapipe instance\n",
    "with mp_pose.Pose(min_detection_confidence=0.5, min_tracking_confidence=0.5) as pose: #.Pose access pose estimation model, #min_tracking_confidence tracks state\n",
    "    while cap.isOpened():\n",
    "        ret, frame = cap.read() # frame is image from camera\n",
    "        \n",
    "        # Recolor image\n",
    "        image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n",
    "        image.flags.writeable = False # save memory\n",
    "        \n",
    "        # Make detection\n",
    "        results = pose.process(image) # image here is RGB\n",
    "        \n",
    "        # Recolor back to BGR\n",
    "        image.flags.writeable = True\n",
    "        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\n",
    "        \n",
    "        # Extract landmarks\n",
    "        try:\n",
    "            landmarks = results.pose_landmarks.landmark # hold landamrks. including x,y,z. Use this for calculating angles\n",
    "            # print(landmarks[mp_pose.PoseLandmark.LEFT_FOOT_INDEX])\n",
    "            # Filter out landmarks with low visibility\n",
    "            shoulder = [landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].x, landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].y]\n",
    "            elbow = [landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].x, landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].y]\n",
    "            wrist = [landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].x, landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].y]    \n",
    "            \n",
    "            # hip = [landmarks[mp_pose.PoseLandmark.LEFT_HIP.value].x, landmarks[mp_pose.PoseLandmark.LEFT_HIP.value].y]\n",
    "            # shoulder = [landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].x, landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].y]\n",
    "            # elbow = [landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].x, landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].y]   \n",
    "            \n",
    "            angle = calculate_angle(shoulder, elbow, wrist)\n",
    "            \n",
    "            # Visualize\n",
    "            cv2.putText(image, \n",
    "                        str(angle),\n",
    "                        tuple(np.multiply(elbow, [640, 480]).astype(int)), # controal [640, 480] to window size\n",
    "                        cv2.FONT_HERSHEY_SIMPLEX, 1, (255,255,255), 2)\n",
    "            \n",
    "            # Curl counter logic\n",
    "            if angle > 160:\n",
    "                stage = \"down\"\n",
    "            if angle < 30 and stage == 'down':\n",
    "                stage = 'up'\n",
    "                counter += 1\n",
    "                print(counter) \n",
    "        except:\n",
    "            pass\n",
    "        \n",
    "        # Render curl counter\n",
    "        cv2.rectangle(image, (0,0), (225,73), (245,117,16), -1)\n",
    "        \n",
    "        cv2.putText(image, 'REPS', (15,20), \n",
    "                    cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1)\n",
    "        cv2.putText(image, str(counter),\n",
    "                    (10,70),\n",
    "                    cv2.FONT_HERSHEY_SIMPLEX, 2, (255,255,255), 2)\n",
    "        \n",
    "        mp_drawing.draw_landmarks(image, results.pose_landmarks, mp_pose.POSE_CONNECTIONS,\n",
    "                                  mp_drawing.DrawingSpec(color=(245,117,66), thickness=2, circle_radius=2),\n",
    "                                  mp_drawing.DrawingSpec(color=(245,66,230), thickness=2, circle_radius=2)) # image here is BGR\n",
    "        \n",
    "        cv2.imshow('Mediappipe Feed', image)\n",
    "        \n",
    "        if cv2.waitKey(10) & 0xFF == ord('q'):\n",
    "            break\n",
    "\n",
    "    cap.release()\n",
    "    cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualize angle vs frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Video"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# For smoothing a curve\n",
    "import numpy as np\n",
    "from scipy.interpolate import interp1d\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.signal import savgol_filter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Smoothing a curve function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# won't be used though\n",
    "import numpy as np\n",
    "from math import factorial\n",
    "def savitzky_golay(y, window_size, order, deriv=0, rate=1):    \n",
    "    \n",
    "    try:\n",
    "        window_size = np.abs(np.int(window_size))\n",
    "        order = np.abs(np.int(order))\n",
    "    except ValueError, msg:\n",
    "        raise ValueError(\"window_size and order have to be of type int\")\n",
    "    if window_size % 2 != 1 or window_size < 1:\n",
    "        raise TypeError(\"window_size size must be a positive odd number\")\n",
    "    if window_size < order + 2:\n",
    "        raise TypeError(\"window_size is too small for the polynomials order\")\n",
    "    order_range = range(order+1)\n",
    "    half_window = (window_size -1) // 2\n",
    "    # precompute coefficients\n",
    "    b = np.mat([[k**i for i in order_range] for k in range(-half_window, half_window+1)])\n",
    "    m = np.linalg.pinv(b).A[deriv] * rate**deriv * factorial(deriv)\n",
    "    # pad the signal at the extremes with\n",
    "    # values taken from the signal itself\n",
    "    firstvals = y[0] - np.abs( y[1:half_window+1][::-1] - y[0] )\n",
    "    lastvals = y[-1] + np.abs(y[-half_window-1:-1][::-1] - y[-1])\n",
    "    y = np.concatenate((firstvals, y, lastvals))\n",
    "    return np.convolve( m[::-1], y, mode='valid')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Apply smoothing curve filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\junsu\\Anaconda3\\envs\\3d-body-demo\\lib\\site-packages\\scipy\\signal\\_savitzky_golay.py:223: RankWarning: Polyfit may be poorly conditioned\n",
      "  _fit_edge(x, 0, window_length, 0, halflen, axis,\n",
      "c:\\Users\\junsu\\Anaconda3\\envs\\3d-body-demo\\lib\\site-packages\\scipy\\signal\\_savitzky_golay.py:226: RankWarning: Polyfit may be poorly conditioned\n",
      "  _fit_edge(x, n - window_length, n, n - halflen, n, axis,\n"
     ]
    }
   ],
   "source": [
    "cap = cv2.VideoCapture(\"Steph Curry.mp4\")\n",
    "\n",
    "# Curl counter variables\n",
    "# counter = 0\n",
    "# stage = None\n",
    "\n",
    "times = []\n",
    "time = 0\n",
    "left_elbow_angles = []\n",
    "left_shoulder_angles = []\n",
    "left_wrist_angles = []\n",
    "left_hip_angles = []\n",
    "left_knee_angles = []\n",
    "right_elbow_angles = []\n",
    "right_shoulder_angles = []\n",
    "right_wrist_angles = []\n",
    "right_hip_angles = []\n",
    "right_knee_angles = []\n",
    "\n",
    "## setup mediapipe instance\n",
    "with mp_pose.Pose(min_detection_confidence=0.5, min_tracking_confidence=0.5) as pose: #.Pose access pose estimation model, #min_tracking_confidence tracks state\n",
    "    while cap.isOpened():\n",
    "        ret, frame = cap.read() # frame is image from camera\n",
    "       \n",
    "        if not ret:\n",
    "            cap.release()\n",
    "            break\n",
    "        \n",
    "        frame_width = int(cap.get(3))\n",
    "        \n",
    "        # Recolor image\n",
    "        image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n",
    "        image.flags.writeable = False # save memory\n",
    "        \n",
    "        # Make detection\n",
    "        results = pose.process(image) # image here is RGB\n",
    "        \n",
    "        # Recolor back to BGR\n",
    "        image.flags.writeable = True\n",
    "        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\n",
    "        \n",
    "        # Extract landmarks\n",
    "        try:\n",
    "            landmarks = results.pose_landmarks.landmark # hold landamrks. including x,y,z. Use this for calculating angles\n",
    "            # print(landmarks[mp_pose.PoseLandmark.LEFT_FOOT_INDEX])\n",
    "            # Filter out landmarks with low visibility\n",
    "            left_shoulder = [landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].x, landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].y, landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].z]\n",
    "            left_elbow = [landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].x, landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].y, landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].z]\n",
    "            left_wrist = [landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].x, landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].y, landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].z]\n",
    "            right_shoulder = [landmarks[mp_pose.PoseLandmark.RIGHT_SHOULDER.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_SHOULDER.value].y]\n",
    "            right_elbow = [landmarks[mp_pose.PoseLandmark.RIGHT_ELBOW.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_ELBOW.value].y]\n",
    "            right_wrist = [landmarks[mp_pose.PoseLandmark.RIGHT_WRIST.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_WRIST.value].y]\n",
    "\n",
    "            # shoulder angle\n",
    "            left_hip = [landmarks[mp_pose.PoseLandmark.LEFT_HIP.value].x, landmarks[mp_pose.PoseLandmark.LEFT_HIP.value].y]\n",
    "            right_hip = [landmarks[mp_pose.PoseLandmark.RIGHT_HIP.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_HIP.value].y]\n",
    "\n",
    "            # wrist angle\n",
    "            left_index = [landmarks[mp_pose.PoseLandmark.LEFT_INDEX.value].x, landmarks[mp_pose.PoseLandmark.LEFT_INDEX.value].y]\n",
    "            right_index = [landmarks[mp_pose.PoseLandmark.RIGHT_INDEX.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_INDEX.value].y]\n",
    "\n",
    "            # hip angle\n",
    "            left_knee = [landmarks[mp_pose.PoseLandmark.LEFT_KNEE.value].x, landmarks[mp_pose.PoseLandmark.LEFT_KNEE.value].y]\n",
    "            right_knee = [landmarks[mp_pose.PoseLandmark.RIGHT_KNEE.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_KNEE.value].y]\n",
    "\n",
    "            # knee angle\n",
    "            left_ankle = [landmarks[mp_pose.PoseLandmark.LEFT_ANKLE.value].x, landmarks[mp_pose.PoseLandmark.LEFT_ANKLE.value].y]\n",
    "            right_ankle = [landmarks[mp_pose.PoseLandmark.RIGHT_ANKLE.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_ANKLE.value].y]\n",
    "            \n",
    "            left_elbow_angle = calculate_angle(left_shoulder, left_elbow, left_wrist)\n",
    "            # left_shoulder_angle = calculate_angle(left_hip, left_shoulder, left_elbow)\n",
    "            # left_wrist_angle = calculate_angle(left_elbow, left_wrist, left_index)\n",
    "            # left_hip_angle = calculate_angle(left_knee, left_hip, left_shoulder)\n",
    "            # left_knee_angle = calculate_angle(left_ankle, left_knee, left_hip)\n",
    "\n",
    "            # right_elbow_angle = calculate_angle(right_shoulder, right_elbow, right_wrist)\n",
    "            # right_shoulder_angle = calculate_angle(right_hip, right_shoulder, right_elbow)\n",
    "            # right_wrist_angle = calculate_angle(right_elbow, right_wrist, right_index)\n",
    "            # right_hip_angle = calculate_angle(right_knee, right_hip, right_shoulder)\n",
    "            # right_knee_angle = calculate_angle(right_ankle, right_knee, right_hip)\n",
    "            \n",
    "            # # if time % 5 == 0:\n",
    "            left_elbow_angles.append(left_elbow_angle)\n",
    "            # left_shoulder_angles.append(left_shoulder_angle)\n",
    "            # left_wrist_angles.append(left_wrist_angle)\n",
    "            # left_hip_angles.append(left_hip_angle)\n",
    "            # left_knee_angles.append(left_knee_angle)\n",
    "\n",
    "            # right_elbow_angles.append(right_elbow_angle)\n",
    "            # right_shoulder_angles.append(right_shoulder_angle)\n",
    "            # right_wrist_angles.append(right_wrist_angle)\n",
    "            # right_hip_angles.append(right_hip_angle)\n",
    "            # right_knee_angles.append(right_knee_angle)\n",
    "\n",
    "            times.append(time)\n",
    "            time+=1\n",
    "            \n",
    "            # Visualize\n",
    "            cv2.putText(image, \n",
    "                        str(angle),\n",
    "                        tuple(np.multiply(elbow, [640, 480]).astype(int)), # controal [640, 480] to window size\n",
    "                        cv2.FONT_HERSHEY_SIMPLEX, 1, (255,255,255), 2)\n",
    "        except:\n",
    "            pass        \n",
    "\n",
    "        mp_drawing.draw_landmarks(image, results.pose_landmarks, mp_pose.POSE_CONNECTIONS,\n",
    "                                  mp_drawing.DrawingSpec(color=(245,117,66), thickness=2, circle_radius=2),\n",
    "                                  mp_drawing.DrawingSpec(color=(245,66,230), thickness=2, circle_radius=2)) # image here is BGR\n",
    "        \n",
    "        cv2.imshow('Mediapipe Feed', image)\n",
    "        \n",
    "        if cv2.waitKey(10) & 0xFF == ord('q'):\n",
    "            break\n",
    "\n",
    "    \n",
    "    cap.release()\n",
    "    cv2.destroyAllWindows()\n",
    "    \n",
    "plt.plot(times, left_elbow_angles, color='b', label = 'left_elbow')\n",
    "\n",
    "## smooth a curve\n",
    "cubic_interpolation_model = interp1d(times, left_elbow_angles, kind = \"cubic\")\n",
    "times = np.array(times)\n",
    "Y_ = cubic_interpolation_model(times)\n",
    "\n",
    "Y_ = savgol_filter(Y_, len(times), 50)\n",
    "plt.plot(times,Y_, color='r', label='smooth')\n",
    "# plt.plot(times, left_shoulder_angles, color='r', label='left_shoulder')\n",
    "# plt.plot(times, left_wrist_angles, color='g', label = 'left wrist')\n",
    "# plt.plot(times, left_hip_angles, color='y', label = 'left hip')\n",
    "# plt.plot(times, left_knee_angles, color='m', label = 'left knee')\n",
    "\n",
    "# plt.plot(times, right_elbow_angles, color='#87CEEB', label = 'right_elbow')\n",
    "# plt.plot(times, right_shoulder_angles, color='#FFC0CB', label='right_shoulder')\n",
    "# plt.plot(times, right_wrist_angles, color='#90EE90', label = 'right wrist')\n",
    "# plt.plot(times, right_hip_angles, color='#FFF01F', label = 'right hip')\n",
    "# plt.plot(times, right_knee_angles, color='#A020F0', label = 'right knee')\n",
    "plt.legend()\n",
    "\n",
    "plt.xlabel('time')\n",
    "plt.ylabel('angle')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Show video and graph. Use pause and play function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Show video and graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "64\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\junsu\\Anaconda3\\envs\\3d-body-demo\\lib\\site-packages\\scipy\\signal\\_savitzky_golay.py:223: RankWarning: Polyfit may be poorly conditioned\n",
      "  _fit_edge(x, 0, window_length, 0, halflen, axis,\n",
      "c:\\Users\\junsu\\Anaconda3\\envs\\3d-body-demo\\lib\\site-packages\\scipy\\signal\\_savitzky_golay.py:226: RankWarning: Polyfit may be poorly conditioned\n",
      "  _fit_edge(x, n - window_length, n, n - halflen, n, axis,\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "64\n",
      "64\n",
      "64\n"
     ]
    }
   ],
   "source": [
    "#Copied from the above cell\n",
    "%matplotlib qt\n",
    "import cv2\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "filename = \"./videos/JJ1.mp4\"\n",
    "cap = cv2.VideoCapture(filename)\n",
    "\n",
    "times = []\n",
    "time = 0\n",
    "left_elbow_angles = []\n",
    "left_shoulder_angles = []\n",
    "left_wrist_angles = []\n",
    "left_hip_angles = []\n",
    "left_knee_angles = []\n",
    "right_elbow_angles = []\n",
    "right_shoulder_angles = []\n",
    "right_wrist_angles = []\n",
    "right_hip_angles = []\n",
    "right_knee_angles = []\n",
    "## setup mediapipe instance\n",
    "images = []\n",
    "with mp_pose.Pose(min_detection_confidence=0.5, min_tracking_confidence=0.5) as pose: #.Pose access pose estimation model, #min_tracking_confidence tracks state\n",
    "    while cap.isOpened():\n",
    "        \n",
    "        ret, frame = cap.read() # frame is image from camera\n",
    "        \n",
    "        if not ret:\n",
    "            cap.release()\n",
    "            break\n",
    "        \n",
    "        frame_width = int(cap.get(3))\n",
    "        \n",
    "        # Recolor image\n",
    "        image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n",
    "        image.flags.writeable = False # save memory\n",
    "        images.append(image)\n",
    "        \n",
    "        # Make detection\n",
    "        results = pose.process(image) # image here is RGB\n",
    "        \n",
    "        # Recolor back to BGR\n",
    "        image.flags.writeable = True\n",
    "        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\n",
    "        \n",
    "        # Extract landmarks\n",
    "        try:\n",
    "            landmarks = results.pose_landmarks.landmark # hold landamrks. including x,y,z. Use this for calculating angles\n",
    "            # print(landmarks[mp_pose.PoseLandmark.LEFT_FOOT_INDEX])\n",
    "            # Filter out landmarks with low visibility\n",
    "            left_shoulder = [landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].x, landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].y]\n",
    "            left_elbow = [landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].x, landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].y]\n",
    "            left_wrist = [landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].x, landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].y]\n",
    "            right_shoulder = [landmarks[mp_pose.PoseLandmark.RIGHT_SHOULDER.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_SHOULDER.value].y]\n",
    "            right_elbow = [landmarks[mp_pose.PoseLandmark.RIGHT_ELBOW.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_ELBOW.value].y]\n",
    "            right_wrist = [landmarks[mp_pose.PoseLandmark.RIGHT_WRIST.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_WRIST.value].y]\n",
    "\n",
    "            # shoulder angle\n",
    "            left_hip = [landmarks[mp_pose.PoseLandmark.LEFT_HIP.value].x, landmarks[mp_pose.PoseLandmark.LEFT_HIP.value].y]\n",
    "            right_hip = [landmarks[mp_pose.PoseLandmark.RIGHT_HIP.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_HIP.value].y]\n",
    "\n",
    "            # wrist angle\n",
    "            left_index = [landmarks[mp_pose.PoseLandmark.LEFT_INDEX.value].x, landmarks[mp_pose.PoseLandmark.LEFT_INDEX.value].y]\n",
    "            right_index = [landmarks[mp_pose.PoseLandmark.RIGHT_INDEX.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_INDEX.value].y]\n",
    "\n",
    "            # hip angle\n",
    "            left_knee = [landmarks[mp_pose.PoseLandmark.LEFT_KNEE.value].x, landmarks[mp_pose.PoseLandmark.LEFT_KNEE.value].y]\n",
    "            right_knee = [landmarks[mp_pose.PoseLandmark.RIGHT_KNEE.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_KNEE.value].y]\n",
    "\n",
    "            # knee angle\n",
    "            left_ankle = [landmarks[mp_pose.PoseLandmark.LEFT_ANKLE.value].x, landmarks[mp_pose.PoseLandmark.LEFT_ANKLE.value].y]\n",
    "            right_ankle = [landmarks[mp_pose.PoseLandmark.RIGHT_ANKLE.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_ANKLE.value].y]\n",
    "            \n",
    "            # left_ = [landmarks[mp_pose.PoseLandmark.LEFT_HIP.value].x, landmarks[mp_pose.PoseLandmark.LEFT_HIP.value].y]\n",
    "\n",
    "            # hip = [landmarks[mp_pose.PoseLandmark.LEFT_HIP.value].x, landmarks[mp_pose.PoseLandmark.LEFT_HIP.value].y]\n",
    "            # shoulder = [landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].x, landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].y]\n",
    "            # elbow = [landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].x, landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].y]   \n",
    "            \n",
    "            left_elbow_angle = calculate_angle(left_shoulder, left_elbow, left_wrist)\n",
    "            left_shoulder_angle = calculate_angle(left_hip, left_shoulder, left_elbow)\n",
    "            left_wrist_angle = calculate_angle(left_elbow, left_wrist, left_index)\n",
    "            left_hip_angle = calculate_angle(left_knee, left_hip, left_shoulder)\n",
    "            left_knee_angle = calculate_angle(left_ankle, left_knee, left_hip)\n",
    "\n",
    "            right_elbow_angle = calculate_angle(right_shoulder, right_elbow, right_wrist)\n",
    "            right_shoulder_angle = calculate_angle(right_hip, right_shoulder, right_elbow)\n",
    "            right_wrist_angle = calculate_angle(right_elbow, right_wrist, right_index)\n",
    "            right_hip_angle = calculate_angle(right_knee, right_hip, right_shoulder)\n",
    "            right_knee_angle = calculate_angle(right_ankle, right_knee, right_hip)\n",
    "            \n",
    "            # if time % 5 == 0:\n",
    "            left_elbow_angles.append(left_elbow_angle)\n",
    "            left_shoulder_angles.append(left_shoulder_angle)\n",
    "            left_wrist_angles.append(left_wrist_angle)\n",
    "            left_hip_angles.append(left_hip_angle)\n",
    "            left_knee_angles.append(left_knee_angle)\n",
    "\n",
    "            right_elbow_angles.append(right_elbow_angle)\n",
    "            right_shoulder_angles.append(right_shoulder_angle)\n",
    "            right_wrist_angles.append(right_wrist_angle)\n",
    "            right_hip_angles.append(right_hip_angle)\n",
    "            right_knee_angles.append(right_knee_angle)\n",
    "\n",
    "            times.append(time)\n",
    "            time+=1\n",
    "            \n",
    "            # Visualize\n",
    "            cv2.putText(image, \n",
    "                        str(left_elbow),\n",
    "                        tuple(np.multiply(left_elbow, [640, 480]).astype(int)), # controal [640, 480] to window size\n",
    "                        cv2.FONT_HERSHEY_SIMPLEX, 1, (255,255,255), 2)\n",
    "        except:\n",
    "           pass      \n",
    "\n",
    "        mp_drawing.draw_landmarks(image, results.pose_landmarks, mp_pose.POSE_CONNECTIONS,\n",
    "                                  mp_drawing.DrawingSpec(color=(245,117,66), thickness=2, circle_radius=2),\n",
    "                                  mp_drawing.DrawingSpec(color=(245,66,230), thickness=2, circle_radius=2)) # image here is BGR\n",
    "        \n",
    "        cv2.imshow('Mediapipe Feed', image)\n",
    "        \n",
    "        if cv2.waitKey(10) & 0xFF == ord('q'):\n",
    "            break\n",
    "\n",
    "    \n",
    "    cap.release()\n",
    "    cv2.destroyAllWindows()\n",
    "    \n",
    "plt.plot(times, left_elbow_angles, color='b', label = 'left_elbow')\n",
    "\n",
    "print(len(left_elbow_angles))\n",
    "\n",
    "\n",
    "## smooth a curve\n",
    "cubic_interpolation_model = interp1d(times, left_elbow_angles, kind = \"cubic\")\n",
    "times = np.array(times)\n",
    "Y_ = cubic_interpolation_model(times)\n",
    "\n",
    "Y_ = savgol_filter(Y_, len(times), 50)\n",
    "plt.plot(times,Y_, color='r', label='smooth')\n",
    "# plt.plot(times, left_shoulder_angles, color='r', label='left_shoulder')\n",
    "# plt.plot(times, left_wrist_angles, color='g', label = 'left wrist')\n",
    "# plt.plot(times, left_hip_angles, color='y', label = 'left hip')\n",
    "# plt.plot(times, left_knee_angles, color='m', label = 'left knee')\n",
    "\n",
    "# plt.plot(times, right_elbow_angles, color='#87CEEB', label = 'right_elbow')\n",
    "# plt.plot(times, right_shoulder_angles, color='#FFC0CB', label='right_shoulder')\n",
    "# plt.plot(times, right_wrist_angles, color='#90EE90', label = 'right wrist')\n",
    "# plt.plot(times, right_hip_angles, color='#FFF01F', label = 'right hip')\n",
    "# plt.plot(times, right_knee_angles, color='#A020F0', label = 'right knee')\n",
    "plt.legend()\n",
    "\n",
    "plt.xlabel('time')\n",
    "plt.ylabel('angle')\n",
    "plt.show()\n",
    "\n",
    "################ show video and graph ######################\n",
    "cap = cv2.VideoCapture(filename)\n",
    "\n",
    "try:\n",
    "    frames = int(cap.get(cv2.cv.CV_CAP_PROP_FRAME_COUNT))\n",
    "    width  = int(cap.get(cv2.cv.CV_CAP_PROP_FRAME_WIDTH))\n",
    "    height = int(cap.get(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT))\n",
    "except AttributeError:\n",
    "    frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))\n",
    "    width  = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))\n",
    "    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))\n",
    "\n",
    "fig, ax = plt.subplots(1,1)\n",
    "plt.ion()\n",
    "plt.show()\n",
    "\n",
    "#Setup a dummy path\n",
    "x = times\n",
    "y = -Y_\n",
    "# need this to plot graph as the original. otherwise upside down\n",
    "left_elbow_angles = (-np.array(left_elbow_angles)).tolist()\n",
    "\n",
    "print(len(images))\n",
    "print(len(times))\n",
    "print(len(y))\n",
    "\n",
    "# for i in enumerate(times): \n",
    "for i, image in enumerate(images):\n",
    "    fig.clf()\n",
    "    flag, frame = cap.read()\n",
    "\n",
    "    plt.imshow(image)\n",
    "    times = times/np.max(times)*width\n",
    "    # plt.plot(x,y,'k-', lw=2)\n",
    "    plt.plot(times, y, 'k-', lw=2)\n",
    "    plt.plot(times, left_elbow_angles, 'g-', lw=2)\n",
    "    plt.plot(times[i],y[i],'or')\n",
    "    plt.pause(0.001)\n",
    "\n",
    "    if cv2.waitKey(10) & 0xFF == ord('q'):\n",
    "        break        \n",
    "        \n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Using seaborn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# This is just a snippet how to use seaborn\n",
    "# https://stackoverflow.com/questions/61368805/how-to-plot-shaded-error-bands-with-seaborn\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "\n",
    "sns.set()\n",
    "N = 100\n",
    "x = np.arange(N)\n",
    "mean_1 = 25 + np.random.normal(0.1, 1, N).cumsum()\n",
    "std_1 = 3 + np.random.normal(0, .08, N).cumsum()\n",
    "\n",
    "mean_2 = 15 + np.random.normal(0.2, 1, N).cumsum()\n",
    "std_2 = 4 + np.random.normal(0, .1, N).cumsum()\n",
    "\n",
    "plt.plot(x, mean_1, 'b-', label='mean_1')\n",
    "plt.fill_between(x, mean_1 - std_1, mean_1 + std_1, color='b', alpha=0.2)\n",
    "plt.plot(x, mean_2, 'r--', label='mean_2')\n",
    "plt.fill_between(x, mean_2 - std_2, mean_2 + std_2, color='r', alpha=0.2)\n",
    "\n",
    "plt.legend(title='title')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "cannot reshape array of size 0 into shape (0,newaxis)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-1-e0b817918bd6>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m    173\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    174\u001b[0m     \u001b[1;31m## smooth a curve\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 175\u001b[1;33m     \u001b[0mcubic_interpolation_model\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0minterp1d\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtimes\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mleft_elbow_angles\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkind\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"cubic\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    176\u001b[0m     \u001b[0mtimes\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtimes\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    177\u001b[0m     \u001b[1;31m# X_ = np.linspace(times.min(), times.max(), 50)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mc:\\Users\\junsu\\Anaconda3\\envs\\3d-body-demo\\lib\\site-packages\\scipy\\interpolate\\_interpolate.py\u001b[0m in \u001b[0;36m__init__\u001b[1;34m(self, x, y, kind, axis, copy, bounds_error, fill_value, assume_sorted)\u001b[0m\n\u001b[0;32m    482\u001b[0m         \u001b[1;31m# Interpolation goes internally along the first axis\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    483\u001b[0m         \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0my\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 484\u001b[1;33m         \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_y\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_reshape_yi\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    485\u001b[0m         \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    486\u001b[0m         \u001b[1;32mdel\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mx\u001b[0m  \u001b[1;31m# clean up namespace to prevent misuse; use attributes\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mc:\\Users\\junsu\\Anaconda3\\envs\\3d-body-demo\\lib\\site-packages\\scipy\\interpolate\\_polyint.py\u001b[0m in \u001b[0;36m_reshape_yi\u001b[1;34m(self, yi, check)\u001b[0m\n\u001b[0;32m    108\u001b[0m                                            self._y_extra_shape[:-self._y_axis])\n\u001b[0;32m    109\u001b[0m             \u001b[1;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Data must be of shape %s\"\u001b[0m \u001b[1;33m%\u001b[0m \u001b[0mok_shape\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 110\u001b[1;33m         \u001b[1;32mreturn\u001b[0m \u001b[0myi\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0myi\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    111\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    112\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0m_set_yi\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0myi\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mxi\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: cannot reshape array of size 0 into shape (0,newaxis)"
     ]
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "\n",
    "#Copied from the above cell\n",
    "%matplotlib qt\n",
    "import cv2\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "\n",
    "import mediapipe as mp\n",
    "\n",
    "# For smoothing a curve\n",
    "# import numpy as np\n",
    "from scipy.interpolate import interp1d\n",
    "# import matplotlib.pyplot as plt\n",
    "from scipy.signal import savgol_filter\n",
    "# import numpy as np\n",
    "mp_drawing = mp.solutions.drawing_utils # when visualing out poses\n",
    "mp_pose = mp.solutions.pose\n",
    "\n",
    "# filename = \"./videos/JJ1.mp4\"\n",
    "filenames = [\"./videos/JJ1.mp4\", \"./videos/Steph Curry.mp4\"]\n",
    "\n",
    "times = []\n",
    "time = 0\n",
    "left_elbow_angles = []\n",
    "left_shoulder_angles = []\n",
    "left_wrist_angles = []\n",
    "left_hip_angles = []\n",
    "left_knee_angles = []\n",
    "right_elbow_angles = []\n",
    "right_shoulder_angles = []\n",
    "right_wrist_angles = []\n",
    "right_hip_angles = []\n",
    "right_knee_angles = []\n",
    "## setup mediapipe instance\n",
    "images = []\n",
    "y_values =[]\n",
    "for filename in filenames:\n",
    "    # clear list \n",
    "    left_elbow_angles.clear()\n",
    "    times = []\n",
    "    time = 0\n",
    "    time_for_seaborn= []\n",
    "    \n",
    "    cap = cv2.VideoCapture(filename)\n",
    "\n",
    "    with mp_pose.Pose(min_detection_confidence=0.5, min_tracking_confidence=0.5) as pose: #.Pose access pose estimation model, #min_tracking_confidence tracks state\n",
    "        while cap.isOpened():\n",
    "            \n",
    "            ret, frame = cap.read() # frame is image from camera\n",
    "            \n",
    "            if not ret:\n",
    "                cap.release()\n",
    "                break\n",
    "            \n",
    "            frame_width = int(cap.get(3))\n",
    "            \n",
    "            # Recolor image\n",
    "            image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n",
    "            image.flags.writeable = False # save memory\n",
    "            images.append(image)\n",
    "            \n",
    "            # Make detection\n",
    "            results = pose.process(image) # image here is RGB\n",
    "            \n",
    "            # Recolor back to BGR\n",
    "            image.flags.writeable = True\n",
    "            image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\n",
    "            \n",
    "            # Extract landmarks\n",
    "            try:\n",
    "                landmarks = results.pose_landmarks.landmark # hold landamrks. including x,y,z. Use this for calculating angles\n",
    "                # print(landmarks[mp_pose.PoseLandmark.LEFT_FOOT_INDEX])\n",
    "                # Filter out landmarks with low visibility\n",
    "                left_shoulder = [landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].x, landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].y]\n",
    "                left_elbow = [landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].x, landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].y]\n",
    "                left_wrist = [landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].x, landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].y]\n",
    "                right_shoulder = [landmarks[mp_pose.PoseLandmark.RIGHT_SHOULDER.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_SHOULDER.value].y]\n",
    "                right_elbow = [landmarks[mp_pose.PoseLandmark.RIGHT_ELBOW.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_ELBOW.value].y]\n",
    "                right_wrist = [landmarks[mp_pose.PoseLandmark.RIGHT_WRIST.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_WRIST.value].y]\n",
    "\n",
    "                # shoulder angle\n",
    "                left_hip = [landmarks[mp_pose.PoseLandmark.LEFT_HIP.value].x, landmarks[mp_pose.PoseLandmark.LEFT_HIP.value].y]\n",
    "                right_hip = [landmarks[mp_pose.PoseLandmark.RIGHT_HIP.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_HIP.value].y]\n",
    "\n",
    "                # wrist angle\n",
    "                left_index = [landmarks[mp_pose.PoseLandmark.LEFT_INDEX.value].x, landmarks[mp_pose.PoseLandmark.LEFT_INDEX.value].y]\n",
    "                right_index = [landmarks[mp_pose.PoseLandmark.RIGHT_INDEX.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_INDEX.value].y]\n",
    "\n",
    "                # hip angle\n",
    "                left_knee = [landmarks[mp_pose.PoseLandmark.LEFT_KNEE.value].x, landmarks[mp_pose.PoseLandmark.LEFT_KNEE.value].y]\n",
    "                right_knee = [landmarks[mp_pose.PoseLandmark.RIGHT_KNEE.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_KNEE.value].y]\n",
    "\n",
    "                # knee angle\n",
    "                left_ankle = [landmarks[mp_pose.PoseLandmark.LEFT_ANKLE.value].x, landmarks[mp_pose.PoseLandmark.LEFT_ANKLE.value].y]\n",
    "                right_ankle = [landmarks[mp_pose.PoseLandmark.RIGHT_ANKLE.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_ANKLE.value].y]\n",
    "\n",
    "                left_elbow_angle = calculate_angle(left_shoulder, left_elbow, left_wrist)\n",
    "                left_shoulder_angle = calculate_angle(left_hip, left_shoulder, left_elbow)\n",
    "                left_wrist_angle = calculate_angle(left_elbow, left_wrist, left_index)\n",
    "                left_hip_angle = calculate_angle(left_knee, left_hip, left_shoulder)\n",
    "                left_knee_angle = calculate_angle(left_ankle, left_knee, left_hip)\n",
    "\n",
    "                right_elbow_angle = calculate_angle(right_shoulder, right_elbow, right_wrist)\n",
    "                right_shoulder_angle = calculate_angle(right_hip, right_shoulder, right_elbow)\n",
    "                right_wrist_angle = calculate_angle(right_elbow, right_wrist, right_index)\n",
    "                right_hip_angle = calculate_angle(right_knee, right_hip, right_shoulder)\n",
    "                right_knee_angle = calculate_angle(right_ankle, right_knee, right_hip)\n",
    "                \n",
    "                # if time % 5 == 0:\n",
    "                left_elbow_angles.append(left_elbow_angle)\n",
    "                left_shoulder_angles.append(left_shoulder_angle)\n",
    "                left_wrist_angles.append(left_wrist_angle)\n",
    "                left_hip_angles.append(left_hip_angle)\n",
    "                left_knee_angles.append(left_knee_angle)\n",
    "\n",
    "                right_elbow_angles.append(right_elbow_angle)\n",
    "                right_shoulder_angles.append(right_shoulder_angle)\n",
    "                right_wrist_angles.append(right_wrist_angle)\n",
    "                right_hip_angles.append(right_hip_angle)\n",
    "                right_knee_angles.append(right_knee_angle)\n",
    "\n",
    "                times.append(time)\n",
    "                time+=1\n",
    "                \n",
    "                # Visualize\n",
    "                cv2.putText(image, \n",
    "                            str(left_elbow),\n",
    "                            tuple(np.multiply(left_elbow, [640, 480]).astype(int)), # controal [640, 480] to window size\n",
    "                            cv2.FONT_HERSHEY_SIMPLEX, 1, (255,255,255), 2)\n",
    "            except:\n",
    "                pass            \n",
    "\n",
    "            mp_drawing.draw_landmarks(image, results.pose_landmarks, mp_pose.POSE_CONNECTIONS,\n",
    "                                    mp_drawing.DrawingSpec(color=(245,117,66), thickness=2, circle_radius=2),\n",
    "                                    mp_drawing.DrawingSpec(color=(245,66,230), thickness=2, circle_radius=2)) # image here is BGR\n",
    "            \n",
    "            cv2.imshow('Mediapipe Feed', image)\n",
    "            \n",
    "            if cv2.waitKey(10) & 0xFF == ord('q'):\n",
    "                break\n",
    "\n",
    "                \n",
    "        cap.release()\n",
    "        cv2.destroyAllWindows()\n",
    "    \n",
    "    \n",
    "    plt.plot(times, left_elbow_angles, color='b', label = 'left_elbow')\n",
    "\n",
    "    ## smooth a curve\n",
    "    cubic_interpolation_model = interp1d(times, left_elbow_angles, kind = \"cubic\")\n",
    "    times = np.array(times)\n",
    "    # X_ = np.linspace(times.min(), times.max(), 50)\n",
    "    Y_ = cubic_interpolation_model(times)\n",
    "\n",
    "    Y_ = savgol_filter(Y_, len(times), 50)\n",
    "    plt.plot(times,Y_, color='r', label='smooth')\n",
    "    # plt.plot(times, left_shoulder_angles, color='r', label='left_shoulder')\n",
    "    # plt.plot(times, left_wrist_angles, color='g', label = 'left wrist')\n",
    "    # plt.plot(times, left_hip_angles, color='y', label = 'left hip')\n",
    "    # plt.plot(times, left_knee_angles, color='m', label = 'left knee')\n",
    "\n",
    "    # plt.plot(times, right_elbow_angles, color='#87CEEB', label = 'right_elbow')\n",
    "    # plt.plot(times, right_shoulder_angles, color='#FFC0CB', label='right_shoulder')\n",
    "    # plt.plot(times, right_wrist_angles, color='#90EE90', label = 'right wrist')\n",
    "    # plt.plot(times, right_hip_angles, color='#FFF01F', label = 'right hip')\n",
    "    # plt.plot(times, right_knee_angles, color='#A020F0', label = 'right knee')\n",
    "    plt.legend()\n",
    "\n",
    "    plt.xlabel('time')\n",
    "    plt.ylabel('angle')\n",
    "    plt.show()\n",
    "\n",
    "    ################ show video and graph ######################\n",
    "    # filename = './Steph Curry.mp4'\n",
    "    cap = cv2.VideoCapture(filename)\n",
    "\n",
    "    try:\n",
    "        frames = int(cap.get(cv2.cv.CV_CAP_PROP_FRAME_COUNT))\n",
    "        width  = int(cap.get(cv2.cv.CV_CAP_PROP_FRAME_WIDTH))\n",
    "        height = int(cap.get(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT))\n",
    "    except AttributeError:\n",
    "        frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))\n",
    "        width  = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))\n",
    "        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))\n",
    "\n",
    "    fig, ax = plt.subplots(1,1)\n",
    "    plt.ion()\n",
    "    plt.show()\n",
    "\n",
    "    x = times\n",
    "    y = -Y_\n",
    "    \n",
    "    # y is array. convert it to list    \n",
    "    y_values += list(y)\n",
    "        \n",
    "    # need this to plot graph as the original. otherwise upside down\n",
    "    left_elbow_angles = (-np.array(left_elbow_angles)).tolist()\n",
    "\n",
    "    print(len(images))\n",
    "    print(len(times))\n",
    "    print(len(y))\n",
    "\n",
    "    # for i in enumerate(times): \n",
    "    for i, image in enumerate(images):\n",
    "        fig.clf()\n",
    "        flag, frame = cap.read()\n",
    "\n",
    "\n",
    "        plt.imshow(image)\n",
    "        times = times/np.max(times)*width\n",
    "        # plt.plot(x,y,'k-', lw=2)\n",
    "        plt.plot(times, y, 'k-', lw=2)\n",
    "        plt.plot(times, left_elbow_angles, 'g-', lw=2)\n",
    "        plt.plot(times[i-1],y[i-1],'or')\n",
    "        plt.pause(0.001)        \n",
    "\n",
    "        if cv2.waitKey(10) & 0xFF == ord('q'):\n",
    "            break       \n",
    "\n",
    "def show_margin(y_values):\n",
    "    print(f'y_values length: {len(y_values)}')\n",
    "    y_values = np.array(y_values).reshape(2, -1)\n",
    "    y_values = np.mean(y_values, axis=0)\n",
    "\n",
    "    print(f'y_values.shape: {y_values.shape}')\n",
    "\n",
    "    x_axis = np.arange(len(y_values))   \n",
    "    plt.plot(x_axis, y_values, 'b-', label='y_value')\n",
    "    plt.fill_between(x_axis, y_values-10, y_values+10, color = 'b', alpha=0.2)\n",
    "\n",
    "    plt.legend(title='test')\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "show_margin(y_values)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Plotting animation for pause and play function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This cell is a simple demo of animation\n",
    "# need PyQt5 to be installed for matplotlib qt\n",
    "%matplotlib qt\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.animation as animation\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "class PauseAnimation:\n",
    "    def __init__(self):\n",
    "        fig, ax = plt.subplots()\n",
    "        ax.set_title('Press any key to pause/resume the animation')\n",
    "        x = np.linspace(-0.1, 0.1, 1000)\n",
    "\n",
    "        # Start with a normal distribution\n",
    "        self.n0 = (1.0 / ((4 * np.pi * 2e-4 * 0.1) ** 0.5)\n",
    "                   * np.exp(-x ** 2 / (4 * 2e-4 * 0.1)))\n",
    "        self.p, = ax.plot(x, self.n0)\n",
    "\n",
    "        self.animation = animation.FuncAnimation(\n",
    "            fig, self.update, frames=200, interval=50, blit=True)\n",
    "        self.paused = False\n",
    "        # 'key_press_event' for keyboard\n",
    "        # 'button_press_event' for mouse button\n",
    "        fig.canvas.mpl_connect('key_press_event', self.toggle_pause)\n",
    "\n",
    "    def toggle_pause(self, *args, **kwargs):\n",
    "        if self.paused:\n",
    "            self.animation.resume()\n",
    "        else:\n",
    "            self.animation.pause()\n",
    "        self.paused = not self.paused\n",
    "\n",
    "    def update(self, i):\n",
    "        self.n0 += i / 100 % 5\n",
    "        self.p.set_ydata(self.n0 % 20)\n",
    "        return (self.p,)\n",
    "\n",
    "\n",
    "pa = PauseAnimation()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Copied from the above cell\n",
    "%matplotlib qt\n",
    "import cv2\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "cap = cv2.VideoCapture(\"Steph Curry.mp4\")\n",
    "\n",
    "# Curl counter variables\n",
    "# counter = 0\n",
    "# stage = None\n",
    "\n",
    "times = []\n",
    "time = 0\n",
    "left_elbow_angles = []\n",
    "left_shoulder_angles = []\n",
    "left_wrist_angles = []\n",
    "left_hip_angles = []\n",
    "left_knee_angles = []\n",
    "right_elbow_angles = []\n",
    "right_shoulder_angles = []\n",
    "right_wrist_angles = []\n",
    "right_hip_angles = []\n",
    "right_knee_angles = []\n",
    "## setup mediapipe instance\n",
    "images = []\n",
    "with mp_pose.Pose(min_detection_confidence=0.5, min_tracking_confidence=0.5) as pose: #.Pose access pose estimation model, #min_tracking_confidence tracks state\n",
    "    while cap.isOpened():\n",
    "        \n",
    "        ret, frame = cap.read() # frame is image from camera\n",
    "        \n",
    "        if not ret:\n",
    "            cap.release()\n",
    "            break\n",
    "        \n",
    "        frame_width = int(cap.get(3))\n",
    "        \n",
    "        # Recolor image\n",
    "        image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n",
    "        image.flags.writeable = False # save memory\n",
    "        images.append(image)\n",
    "        \n",
    "        # Make detection\n",
    "        results = pose.process(image) # image here is RGB\n",
    "        \n",
    "        # Recolor back to BGR\n",
    "        image.flags.writeable = True\n",
    "        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\n",
    "        \n",
    "        # Extract landmarks\n",
    "        try:\n",
    "            landmarks = results.pose_landmarks.landmark # hold landamrks. including x,y,z. Use this for calculating angles\n",
    "            # print(landmarks[mp_pose.PoseLandmark.LEFT_FOOT_INDEX])\n",
    "            # Filter out landmarks with low visibility\n",
    "            left_shoulder = [landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].x, landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].y]\n",
    "            left_elbow = [landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].x, landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].y]\n",
    "            left_wrist = [landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].x, landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].y]\n",
    "            right_shoulder = [landmarks[mp_pose.PoseLandmark.RIGHT_SHOULDER.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_SHOULDER.value].y]\n",
    "            right_elbow = [landmarks[mp_pose.PoseLandmark.RIGHT_ELBOW.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_ELBOW.value].y]\n",
    "            right_wrist = [landmarks[mp_pose.PoseLandmark.RIGHT_WRIST.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_WRIST.value].y]\n",
    "\n",
    "            # shoulder angle\n",
    "            left_hip = [landmarks[mp_pose.PoseLandmark.LEFT_HIP.value].x, landmarks[mp_pose.PoseLandmark.LEFT_HIP.value].y]\n",
    "            right_hip = [landmarks[mp_pose.PoseLandmark.RIGHT_HIP.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_HIP.value].y]\n",
    "\n",
    "            # wrist angle\n",
    "            left_index = [landmarks[mp_pose.PoseLandmark.LEFT_INDEX.value].x, landmarks[mp_pose.PoseLandmark.LEFT_INDEX.value].y]\n",
    "            right_index = [landmarks[mp_pose.PoseLandmark.RIGHT_INDEX.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_INDEX.value].y]\n",
    "\n",
    "            # hip angle\n",
    "            left_knee = [landmarks[mp_pose.PoseLandmark.LEFT_KNEE.value].x, landmarks[mp_pose.PoseLandmark.LEFT_KNEE.value].y]\n",
    "            right_knee = [landmarks[mp_pose.PoseLandmark.RIGHT_KNEE.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_KNEE.value].y]\n",
    "\n",
    "            # knee angle\n",
    "            left_ankle = [landmarks[mp_pose.PoseLandmark.LEFT_ANKLE.value].x, landmarks[mp_pose.PoseLandmark.LEFT_ANKLE.value].y]\n",
    "            right_ankle = [landmarks[mp_pose.PoseLandmark.RIGHT_ANKLE.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_ANKLE.value].y]\n",
    "\n",
    "            left_elbow_angle = calculate_angle(left_shoulder, left_elbow, left_wrist)\n",
    "            left_shoulder_angle = calculate_angle(left_hip, left_shoulder, left_elbow)\n",
    "            left_wrist_angle = calculate_angle(left_elbow, left_wrist, left_index)\n",
    "            left_hip_angle = calculate_angle(left_knee, left_hip, left_shoulder)\n",
    "            left_knee_angle = calculate_angle(left_ankle, left_knee, left_hip)\n",
    "\n",
    "            right_elbow_angle = calculate_angle(right_shoulder, right_elbow, right_wrist)\n",
    "            right_shoulder_angle = calculate_angle(right_hip, right_shoulder, right_elbow)\n",
    "            right_wrist_angle = calculate_angle(right_elbow, right_wrist, right_index)\n",
    "            right_hip_angle = calculate_angle(right_knee, right_hip, right_shoulder)\n",
    "            right_knee_angle = calculate_angle(right_ankle, right_knee, right_hip)\n",
    "            \n",
    "            # if time % 5 == 0:\n",
    "            left_elbow_angles.append(left_elbow_angle)\n",
    "            left_shoulder_angles.append(left_shoulder_angle)\n",
    "            left_wrist_angles.append(left_wrist_angle)\n",
    "            left_hip_angles.append(left_hip_angle)\n",
    "            left_knee_angles.append(left_knee_angle)\n",
    "\n",
    "            right_elbow_angles.append(right_elbow_angle)\n",
    "            right_shoulder_angles.append(right_shoulder_angle)\n",
    "            right_wrist_angles.append(right_wrist_angle)\n",
    "            right_hip_angles.append(right_hip_angle)\n",
    "            right_knee_angles.append(right_knee_angle)\n",
    "\n",
    "            times.append(time)\n",
    "            time+=1\n",
    "            \n",
    "            # Visualize\n",
    "            cv2.putText(image, \n",
    "                        str(angle),\n",
    "                        tuple(np.multiply(elbow, [640, 480]).astype(int)), # controal [640, 480] to window size\n",
    "                        cv2.FONT_HERSHEY_SIMPLEX, 1, (255,255,255), 2)\n",
    "        except:\n",
    "            pass     \n",
    "\n",
    "        mp_drawing.draw_landmarks(image, results.pose_landmarks, mp_pose.POSE_CONNECTIONS,\n",
    "                                  mp_drawing.DrawingSpec(color=(245,117,66), thickness=2, circle_radius=2),\n",
    "                                  mp_drawing.DrawingSpec(color=(245,66,230), thickness=2, circle_radius=2)) # image here is BGR\n",
    "        \n",
    "        cv2.imshow('Mediapipe Feed', image)\n",
    "        \n",
    "        if cv2.waitKey(10) & 0xFF == ord('q'):\n",
    "            break\n",
    "\n",
    "    \n",
    "    cap.release()\n",
    "    cv2.destroyAllWindows()\n",
    "    \n",
    "plt.plot(times, left_elbow_angles, color='b', label = 'left_elbow')\n",
    "\n",
    "## smooth a curve\n",
    "cubic_interpolation_model = interp1d(times, left_elbow_angles, kind = \"cubic\")\n",
    "times = np.array(times)\n",
    "Y_ = cubic_interpolation_model(times)\n",
    "\n",
    "Y_ = savgol_filter(Y_, len(times), 50)\n",
    "plt.plot(times,Y_, color='r', label='smooth')\n",
    "# plt.plot(times, left_shoulder_angles, color='r', label='left_shoulder')\n",
    "# plt.plot(times, left_wrist_angles, color='g', label = 'left wrist')\n",
    "# plt.plot(times, left_hip_angles, color='y', label = 'left hip')\n",
    "# plt.plot(times, left_knee_angles, color='m', label = 'left knee')\n",
    "\n",
    "# plt.plot(times, right_elbow_angles, color='#87CEEB', label = 'right_elbow')\n",
    "# plt.plot(times, right_shoulder_angles, color='#FFC0CB', label='right_shoulder')\n",
    "# plt.plot(times, right_wrist_angles, color='#90EE90', label = 'right wrist')\n",
    "# plt.plot(times, right_hip_angles, color='#FFF01F', label = 'right hip')\n",
    "# plt.plot(times, right_knee_angles, color='#A020F0', label = 'right knee')\n",
    "plt.legend()\n",
    "\n",
    "plt.xlabel('time')\n",
    "plt.ylabel('angle')\n",
    "plt.show()\n",
    "\n",
    "################ show video and graph ######################\n",
    "filename = './Steph Curry.mp4'\n",
    "cap = cv2.VideoCapture(filename)\n",
    "\n",
    "try:\n",
    "    frames = int(cap.get(cv2.cv.CV_CAP_PROP_FRAME_COUNT))\n",
    "    width  = int(cap.get(cv2.cv.CV_CAP_PROP_FRAME_WIDTH))\n",
    "    height = int(cap.get(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT))\n",
    "except AttributeError:\n",
    "    frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))\n",
    "    width  = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))\n",
    "    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))\n",
    "\n",
    "fig, ax = plt.subplots(1,1)\n",
    "plt.ion()\n",
    "plt.show()\n",
    "\n",
    "\n",
    "x = times\n",
    "y = -Y_\n",
    "\n",
    "# need this to plot graph as the original. otherwise upside down\n",
    "left_elbow_angles = (-np.array(left_elbow_angles)).tolist()\n",
    "for i, image in enumerate(images): \n",
    "\n",
    "    fig.clf()\n",
    "    flag, frame = cap.read()\n",
    "    # image.flags.writeable = False # save memory\n",
    "    plt.imshow(image)\n",
    "    # match plot size with video\n",
    "    times = times/np.max(times)*width\n",
    "    \n",
    "    plt.plot(times, y, 'k-', lw=2)\n",
    "    plt.plot(times, left_elbow_angles, 'g-', lw=2)\n",
    "    plt.plot(times[i],y[i],'or')\n",
    "    plt.pause(0.001)\n",
    "\n",
    "    if cv2.waitKey(10) & 0xFF == ord('q'):\n",
    "        break        \n",
    "        \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Camera"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'angle')"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cap = cv2.VideoCapture(0)\n",
    "\n",
    "times = []\n",
    "time = 0\n",
    "left_elbow_angles = []\n",
    "left_shoulder_angles = []\n",
    "left_wrist_angles = []\n",
    "left_hip_angles = []\n",
    "left_knee_angles = []\n",
    "right_elbow_angles = []\n",
    "right_shoulder_angles = []\n",
    "right_wrist_angles = []\n",
    "right_hip_angles = []\n",
    "right_knee_angles = []\n",
    "## setup mediapipe instance\n",
    "with mp_pose.Pose(min_detection_confidence=0.5, min_tracking_confidence=0.5) as pose: #.Pose access pose estimation model, #min_tracking_confidence tracks state\n",
    "    while cap.isOpened():\n",
    "        ret, frame = cap.read() # frame is image from camera\n",
    "        \n",
    "        # Recolor image\n",
    "        image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n",
    "        image.flags.writeable = False # save memory\n",
    "        \n",
    "        # Make detection\n",
    "        results = pose.process(image) # image here is RGB\n",
    "        \n",
    "        # Recolor back to BGR\n",
    "        image.flags.writeable = True\n",
    "        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\n",
    "        \n",
    "        # Extract landmarks\n",
    "        try:\n",
    "            landmarks = results.pose_landmarks.landmark # hold landamrks. including x,y,z. Use this for calculating angles\n",
    "            # print(landmarks[mp_pose.PoseLandmark.LEFT_FOOT_INDEX])\n",
    "            # Filter out landmarks with low visibility\n",
    "            left_shoulder = [landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].x, landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].y, landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER.value].z]\n",
    "            left_elbow = [landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].x, landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].y, landmarks[mp_pose.PoseLandmark.LEFT_ELBOW.value].z]\n",
    "            left_wrist = [landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].x, landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].y, landmarks[mp_pose.PoseLandmark.LEFT_WRIST.value].z]\n",
    "            right_shoulder = [landmarks[mp_pose.PoseLandmark.RIGHT_SHOULDER.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_SHOULDER.value].y]\n",
    "            right_elbow = [landmarks[mp_pose.PoseLandmark.RIGHT_ELBOW.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_ELBOW.value].y]\n",
    "            right_wrist = [landmarks[mp_pose.PoseLandmark.RIGHT_WRIST.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_WRIST.value].y]\n",
    "\n",
    "            # shoulder angle\n",
    "            left_hip = [landmarks[mp_pose.PoseLandmark.LEFT_HIP.value].x, landmarks[mp_pose.PoseLandmark.LEFT_HIP.value].y]\n",
    "            right_hip = [landmarks[mp_pose.PoseLandmark.RIGHT_HIP.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_HIP.value].y]\n",
    "\n",
    "            # wrist angle\n",
    "            left_index = [landmarks[mp_pose.PoseLandmark.LEFT_INDEX.value].x, landmarks[mp_pose.PoseLandmark.LEFT_INDEX.value].y]\n",
    "            right_index = [landmarks[mp_pose.PoseLandmark.RIGHT_INDEX.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_INDEX.value].y]\n",
    "\n",
    "            # hip angle\n",
    "            left_knee = [landmarks[mp_pose.PoseLandmark.LEFT_KNEE.value].x, landmarks[mp_pose.PoseLandmark.LEFT_KNEE.value].y]\n",
    "            right_knee = [landmarks[mp_pose.PoseLandmark.RIGHT_KNEE.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_KNEE.value].y]\n",
    "\n",
    "            # knee angle\n",
    "            left_ankle = [landmarks[mp_pose.PoseLandmark.LEFT_ANKLE.value].x, landmarks[mp_pose.PoseLandmark.LEFT_ANKLE.value].y]\n",
    "            right_ankle = [landmarks[mp_pose.PoseLandmark.RIGHT_ANKLE.value].x, landmarks[mp_pose.PoseLandmark.RIGHT_ANKLE.value].y]\n",
    "            left_elbow_angle = calculate_angle(left_shoulder, left_elbow, left_wrist)\n",
    "            # left_shoulder_angle = calculate_angle(left_hip, left_shoulder, left_elbow)\n",
    "            # left_wrist_angle = calculate_angle(left_elbow, left_wrist, left_index)\n",
    "            # left_hip_angle = calculate_angle(left_knee, left_hip, left_shoulder)\n",
    "            # left_knee_angle = calculate_angle(left_ankle, left_knee, left_hip)\n",
    "\n",
    "            # right_elbow_angle = calculate_angle(right_shoulder, right_elbow, right_wrist)\n",
    "            # right_shoulder_angle = calculate_angle(right_hip, right_shoulder, right_elbow)\n",
    "            # right_wrist_angle = calculate_angle(right_elbow, right_wrist, right_index)\n",
    "            # right_hip_angle = calculate_angle(right_knee, right_hip, right_shoulder)\n",
    "            # right_knee_angle = calculate_angle(right_ankle, right_knee, right_hip)\n",
    "            \n",
    "            # if time % 5 == 0:\n",
    "            left_elbow_angles.append(left_elbow_angle)\n",
    "            # left_shoulder_angles.append(left_shoulder_angle)\n",
    "            # left_wrist_angles.append(left_wrist_angle)\n",
    "            # left_hip_angles.append(left_hip_angle)\n",
    "            # left_knee_angles.append(left_knee_angle)\n",
    "\n",
    "            # right_elbow_angles.append(right_elbow_angle)\n",
    "            # right_shoulder_angles.append(right_shoulder_angle)\n",
    "            # right_wrist_angles.append(right_wrist_angle)\n",
    "            # right_hip_angles.append(right_hip_angle)\n",
    "            # right_knee_angles.append(right_knee_angle)\n",
    "\n",
    "            times.append(time)\n",
    "            time+=1\n",
    "            \n",
    "            # Visualize\n",
    "            cv2.putText(image, \n",
    "                        str(left_elbow_angle),\n",
    "                        tuple(np.multiply(left_elbow[0:2], [640, 480]).astype(int)), # controal [640, 480] to window size\n",
    "                        cv2.FONT_HERSHEY_SIMPLEX, 1, (255,255,255), 2)\n",
    "        except:\n",
    "            pass\n",
    "        \n",
    "        mp_drawing.draw_landmarks(image, results.pose_landmarks, mp_pose.POSE_CONNECTIONS,\n",
    "                                  mp_drawing.DrawingSpec(color=(245,117,66), thickness=2, circle_radius=2),\n",
    "                                  mp_drawing.DrawingSpec(color=(245,66,230), thickness=2, circle_radius=2)) # image here is BGR\n",
    "        \n",
    "        cv2.imshow('Mediappipe Feed', image)\n",
    "        \n",
    "        if cv2.waitKey(10) & 0xFF == ord('q'):\n",
    "            break\n",
    "\n",
    "    cap.release()\n",
    "    cv2.destroyAllWindows()\n",
    "    \n",
    "plt.plot(times, left_elbow_angles, color='b', label = 'left_elbow')\n",
    "# plt.plot(times, left_shoulder_angles, color='r', label='left_shoulder')\n",
    "# plt.plot(times, left_wrist_angles, color='g', label = 'left wrist')\n",
    "# plt.plot(times, left_hip_angles, color='y', label = 'left hip')\n",
    "# plt.plot(times, left_knee_angles, color='m', label = 'left knee')\n",
    "\n",
    "# plt.plot(times, right_elbow_angles, color='#87CEEB', label = 'right_elbow')\n",
    "# plt.plot(times, right_shoulder_angles, color='#FFC0CB', label='right_shoulder')\n",
    "# plt.plot(times, right_wrist_angles, color='#90EE90', label = 'right wrist')\n",
    "# plt.plot(times, right_hip_angles, color='#FFF01F', label = 'right hip')\n",
    "# plt.plot(times, right_knee_angles, color='#A020F0', label = 'right knee')\n",
    "plt.legend()\n",
    "\n",
    "plt.xlabel('time')\n",
    "plt.ylabel('angle')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.0 ('3d-body-demo')",
   "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.0 (default, Nov  6 2019, 16:00:02) [MSC v.1916 64 bit (AMD64)]"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "027937559ea221be218e012da6804f60232756f151ea6bf940274a4dffa14d8c"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}