{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "objc[68038]: Class CaptureDelegate is implemented in both /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/mediapipe/.dylibs/libopencv_videoio.3.4.16.dylib (0x10c548860) and /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/cv2/cv2.abi3.so (0x17b5da480). One of the two will be used. Which one is undefined.\n", "objc[68038]: Class CVWindow is implemented in both /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/mediapipe/.dylibs/libopencv_highgui.3.4.16.dylib (0x107304a68) and /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/cv2/cv2.abi3.so (0x17b5da4d0). One of the two will be used. Which one is undefined.\n", "objc[68038]: Class CVView is implemented in both /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/mediapipe/.dylibs/libopencv_highgui.3.4.16.dylib (0x107304a90) and /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/cv2/cv2.abi3.so (0x17b5da4f8). One of the two will be used. Which one is undefined.\n", "objc[68038]: Class CVSlider is implemented in both /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/mediapipe/.dylibs/libopencv_highgui.3.4.16.dylib (0x107304ab8) and /Users/fuixlabsdev1/Programming/PP/graduation-thesis/env/lib/python3.8/site-packages/cv2/cv2.abi3.so (0x17b5da520). One of the two will be used. Which one is undefined.\n" ] } ], "source": [ "import mediapipe as mp\n", "import cv2\n", "import numpy as np\n", "import pandas as pd\n", "import csv\n", "import os\n", "import seaborn as sns\n", "\n", "import warnings\n", "warnings.filterwarnings('ignore')\n", "\n", "# Drawing helpers\n", "mp_drawing = mp.solutions.drawing_utils\n", "mp_pose = mp.solutions.pose" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1. Build dataset from collected video" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.1. Determine important landmarks and set up important functions\n", "\n", "The error that I try to tackle is **KNEE OVER TOE** error when lunge is at down stage.\n", "- \"C\": Correct Form\n", "- \"L\": Incorrect Form" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "# Determine important landmarks for lunge\n", "IMPORTANT_LMS = [\n", " \"NOSE\",\n", " \"LEFT_SHOULDER\",\n", " \"RIGHT_SHOULDER\",\n", " \"LEFT_HIP\",\n", " \"RIGHT_HIP\",\n", " \"LEFT_KNEE\",\n", " \"RIGHT_KNEE\",\n", " \"LEFT_ANKLE\",\n", " \"RIGHT_ANKLE\",\n", " \"LEFT_HEEL\",\n", " \"RIGHT_HEEL\",\n", " \"LEFT_FOOT_INDEX\",\n", " \"RIGHT_FOOT_INDEX\",\n", "]\n", "\n", "# Generate all columns of the data frame\n", "HEADERS = [\"label\"] # Label column\n", "\n", "for lm in IMPORTANT_LMS:\n", " HEADERS += [f\"{lm.lower()}_x\", f\"{lm.lower()}_y\", f\"{lm.lower()}_z\", f\"{lm.lower()}_v\"]" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "def rescale_frame(frame, percent=50):\n", " '''\n", " Rescale a frame to a certain percentage compare to its original frame\n", " '''\n", " width = int(frame.shape[1] * percent/ 100)\n", " height = int(frame.shape[0] * percent/ 100)\n", " dim = (width, height)\n", " return cv2.resize(frame, dim, interpolation = cv2.INTER_AREA)\n", " \n", "\n", "def init_csv(dataset_path: str):\n", " '''\n", " Create a blank csv file with just columns\n", " '''\n", "\n", " # Ignore if file is already exist\n", " if os.path.exists(dataset_path):\n", " return\n", "\n", " # Write all the columns to a empty file\n", " with open(dataset_path, mode=\"w\", newline=\"\") as f:\n", " csv_writer = csv.writer(f, delimiter=\",\", quotechar='\"', quoting=csv.QUOTE_MINIMAL)\n", " csv_writer.writerow(HEADERS)\n", "\n", "\n", "def export_landmark_to_csv(dataset_path: str, results, action: str) -> None:\n", " '''\n", " Export Labeled Data from detected landmark to csv\n", " '''\n", " landmarks = results.pose_landmarks.landmark\n", " keypoints = []\n", "\n", " try:\n", " # Extract coordinate of important landmarks\n", " for lm in IMPORTANT_LMS:\n", " keypoint = landmarks[mp_pose.PoseLandmark[lm].value]\n", " keypoints.append([keypoint.x, keypoint.y, keypoint.z, keypoint.visibility])\n", " \n", " keypoints = list(np.array(keypoints).flatten())\n", "\n", " # Insert action as the label (first column)\n", " keypoints.insert(0, action)\n", "\n", " # Append new row to .csv file\n", " with open(dataset_path, mode=\"a\", newline=\"\") as f:\n", " csv_writer = csv.writer(f, delimiter=\",\", quotechar='\"', quoting=csv.QUOTE_MINIMAL)\n", " csv_writer.writerow(keypoints)\n", " \n", "\n", " except Exception as e:\n", " print(e)\n", " pass\n", "\n", "\n", "def describe_dataset(dataset_path: str):\n", " '''\n", " Describe dataset\n", " '''\n", "\n", " data = pd.read_csv(dataset_path)\n", " print(f\"Headers: {list(data.columns.values)}\")\n", " print(f'Number of rows: {data.shape[0]} \\nNumber of columns: {data.shape[1]}\\n')\n", " print(f\"Labels: \\n{data['label'].value_counts()}\\n\")\n", " print(f\"Missing values: {data.isnull().values.any()}\\n\")\n", " \n", " duplicate = data[data.duplicated()]\n", " print(f\"Duplicate Rows : {len(duplicate.sum(axis=1))}\")\n", "\n", " return data\n", "\n", "\n", "def remove_duplicate_rows(dataset_path: str):\n", " '''\n", " Remove duplicated data from the dataset then save it to another files\n", " '''\n", " \n", " df = pd.read_csv(dataset_path)\n", " df.drop_duplicates(keep=\"first\", inplace=True)\n", " df.to_csv(f\"cleaned_dataset.csv\", sep=',', encoding='utf-8', index=False)\n", " \n", "\n", "def concat_csv_files_with_same_headers(file_paths: list, saved_path: str):\n", " '''\n", " Concat different csv files\n", " '''\n", " all_df = []\n", " for path in file_paths:\n", " df = pd.read_csv(path, index_col=None, header=0)\n", " all_df.append(df)\n", " \n", " results = pd.concat(all_df, axis=0, ignore_index=True)\n", " results.to_csv(saved_path, sep=',', encoding='utf-8', index=False)\n", "\n", "\n", "def calculate_angle(point1: list, point2: list, point3: list) -> float:\n", " '''\n", " Calculate the angle between 3 points\n", " Unit of the angle will be in Degree\n", " '''\n", " point1 = np.array(point1)\n", " point2 = np.array(point2)\n", " point3 = np.array(point3)\n", "\n", " # Calculate algo\n", " angleInRad = np.arctan2(point3[1] - point2[1], point3[0] - point2[0]) - np.arctan2(point1[1] - point2[1], point1[0] - point2[0])\n", " angleInDeg = np.abs(angleInRad * 180.0 / np.pi)\n", "\n", " angleInDeg = angleInDeg if angleInDeg <= 180 else 360 - angleInDeg\n", " return angleInDeg" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.2. Extract data for train set" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "OpenCV: Couldn't read video stream from file \"../data/lunge/lunge_9.mp4\"\n" ] } ], "source": [ "DATASET_PATH = \"err.train.csv\"\n", "\n", "cap = cv2.VideoCapture(\"../data/lunge/lunge_9.mp4\")\n", "save_counts = 0\n", "\n", "init_csv(DATASET_PATH)\n", "\n", "with mp_pose.Pose(min_detection_confidence=0.8, min_tracking_confidence=0.9) as pose:\n", " while cap.isOpened():\n", " ret, image = cap.read()\n", "\n", " if not ret:\n", " break\n", "\n", " # Reduce size of a frame\n", " image = rescale_frame(image, 60)\n", " # image = cv2.flip(image, 1)\n", "\n", " video_dimensions = [image.shape[1], image.shape[0]]\n", "\n", " # Recolor image from BGR to RGB for mediapipe\n", " image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n", " image.flags.writeable = False\n", "\n", " results = pose.process(image)\n", " \n", " if not results.pose_landmarks: continue\n", "\n", " landmarks = results.pose_landmarks.landmark\n", "\n", " # Recolor image from BGR to RGB for mediapipe\n", " image.flags.writeable = True\n", " image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\n", "\n", " # Draw landmarks and connections\n", " mp_drawing.draw_landmarks(image, results.pose_landmarks, mp_pose.POSE_CONNECTIONS, mp_drawing.DrawingSpec(color=(244, 117, 66), thickness=2, circle_radius=4), mp_drawing.DrawingSpec(color=(245, 66, 230), thickness=2, circle_radius=2))\n", "\n", " # Display the saved count\n", " cv2.putText(image, f\"Saved: {save_counts}\", (50, 50), cv2.FONT_HERSHEY_COMPLEX, 2, (0, 0, 0), 2, cv2.LINE_AA)\n", "\n", " cv2.imshow(\"CV2\", image)\n", "\n", " # Pressed key for action\n", " k = cv2.waitKey(1) & 0xFF\n", "\n", " # * Press I to save as INIT stage\n", " if k == ord('c'): \n", " export_landmark_to_csv(DATASET_PATH, results, \"C\")\n", " save_counts += 1\n", " # * Press M to save as MID stage\n", " elif k == ord(\"l\"):\n", " export_landmark_to_csv(DATASET_PATH, results, \"L\")\n", " save_counts += 1\n", "\n", " # Press q to stop\n", " elif k == ord(\"q\"):\n", " break\n", " else: continue\n", "\n", " cap.release()\n", " cv2.destroyAllWindows()\n", "\n", " # (Optional)Fix bugs cannot close windows in MacOS (https://stackoverflow.com/questions/6116564/destroywindow-does-not-close-window-on-mac-using-python-and-opencv)\n", " for i in range (1, 5):\n", " cv2.waitKey(1)\n", " " ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Headers: ['label', 'nose_x', 'nose_y', 'nose_z', 'nose_v', 'left_shoulder_x', 'left_shoulder_y', 'left_shoulder_z', 'left_shoulder_v', 'right_shoulder_x', 'right_shoulder_y', 'right_shoulder_z', 'right_shoulder_v', 'left_hip_x', 'left_hip_y', 'left_hip_z', 'left_hip_v', 'right_hip_x', 'right_hip_y', 'right_hip_z', 'right_hip_v', 'left_knee_x', 'left_knee_y', 'left_knee_z', 'left_knee_v', 'right_knee_x', 'right_knee_y', 'right_knee_z', 'right_knee_v', 'left_ankle_x', 'left_ankle_y', 'left_ankle_z', 'left_ankle_v', 'right_ankle_x', 'right_ankle_y', 'right_ankle_z', 'right_ankle_v', 'left_heel_x', 'left_heel_y', 'left_heel_z', 'left_heel_v', 'right_heel_x', 'right_heel_y', 'right_heel_z', 'right_heel_v', 'left_foot_index_x', 'left_foot_index_y', 'left_foot_index_z', 'left_foot_index_v', 'right_foot_index_x', 'right_foot_index_y', 'right_foot_index_z', 'right_foot_index_v']\n", "Number of rows: 17907 \n", "Number of columns: 53\n", "\n", "Labels: \n", "L 9114\n", "C 8793\n", "Name: label, dtype: int64\n", "\n", "Missing values: False\n", "\n", "Duplicate Rows : 0\n" ] } ], "source": [ "df = describe_dataset(DATASET_PATH)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.3. Extract data for test set" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "TEST_DATASET_PATH = \"err.test.csv\"\n", "\n", "cap = cv2.VideoCapture(\"../data/lunge/lunge_test_5.mp4\")\n", "save_counts = 0\n", "\n", "init_csv(TEST_DATASET_PATH)\n", "\n", "with mp_pose.Pose(min_detection_confidence=0.5, min_tracking_confidence=0.8) as pose:\n", " while cap.isOpened():\n", " ret, image = cap.read()\n", "\n", " if not ret:\n", " break\n", "\n", " # Reduce size of a frame\n", " image = rescale_frame(image, 60)\n", " image = cv2.flip(image, 1)\n", "\n", " video_dimensions = [image.shape[1], image.shape[0]]\n", "\n", " # Recolor image from BGR to RGB for mediapipe\n", " image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n", " image.flags.writeable = False\n", "\n", " results = pose.process(image)\n", " \n", " if not results.pose_landmarks: continue\n", "\n", " landmarks = results.pose_landmarks.landmark\n", "\n", " # Recolor image from BGR to RGB for mediapipe\n", " image.flags.writeable = True\n", " image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\n", "\n", " # Draw landmarks and connections\n", " mp_drawing.draw_landmarks(image, results.pose_landmarks, mp_pose.POSE_CONNECTIONS, mp_drawing.DrawingSpec(color=(244, 117, 66), thickness=2, circle_radius=4), mp_drawing.DrawingSpec(color=(245, 66, 230), thickness=2, circle_radius=2))\n", "\n", " # Display the saved count\n", " cv2.putText(image, f\"Saved: {save_counts}\", (50, 50), cv2.FONT_HERSHEY_COMPLEX, 2, (0, 0, 0), 2, cv2.LINE_AA)\n", "\n", " cv2.imshow(\"CV2\", image)\n", "\n", " # Pressed key for action\n", " k = cv2.waitKey(10) & 0xFF\n", "\n", " # * Press C to save as Correct stage\n", " if k == ord('c'): \n", " export_landmark_to_csv(TEST_DATASET_PATH, results, \"C\")\n", " save_counts += 1\n", " # * Press L to save as Incorrect stage\n", " elif k == ord(\"l\"):\n", " export_landmark_to_csv(TEST_DATASET_PATH, results, \"L\")\n", " save_counts += 1\n", "\n", " # Press q to stop\n", " elif k == ord(\"q\"):\n", " break\n", " else: continue\n", "\n", " cap.release()\n", " cv2.destroyAllWindows()\n", "\n", " # (Optional)Fix bugs cannot close windows in MacOS (https://stackoverflow.com/questions/6116564/destroywindow-does-not-close-window-on-mac-using-python-and-opencv)\n", " for i in range (1, 5):\n", " cv2.waitKey(1)\n", " " ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Headers: ['label', 'nose_x', 'nose_y', 'nose_z', 'nose_v', 'left_shoulder_x', 'left_shoulder_y', 'left_shoulder_z', 'left_shoulder_v', 'right_shoulder_x', 'right_shoulder_y', 'right_shoulder_z', 'right_shoulder_v', 'left_hip_x', 'left_hip_y', 'left_hip_z', 'left_hip_v', 'right_hip_x', 'right_hip_y', 'right_hip_z', 'right_hip_v', 'left_knee_x', 'left_knee_y', 'left_knee_z', 'left_knee_v', 'right_knee_x', 'right_knee_y', 'right_knee_z', 'right_knee_v', 'left_ankle_x', 'left_ankle_y', 'left_ankle_z', 'left_ankle_v', 'right_ankle_x', 'right_ankle_y', 'right_ankle_z', 'right_ankle_v', 'left_heel_x', 'left_heel_y', 'left_heel_z', 'left_heel_v', 'right_heel_x', 'right_heel_y', 'right_heel_z', 'right_heel_v', 'left_foot_index_x', 'left_foot_index_y', 'left_foot_index_z', 'left_foot_index_v', 'right_foot_index_x', 'right_foot_index_y', 'right_foot_index_z', 'right_foot_index_v']\n", "Number of rows: 783 \n", "Number of columns: 53\n", "\n", "Labels: \n", "L 406\n", "C 377\n", "Name: label, dtype: int64\n", "\n", "Missing values: False\n", "\n", "Duplicate Rows : 0\n" ] } ], "source": [ "test_df = describe_dataset(TEST_DATASET_PATH)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3. Data Visualization" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.1. Train set" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Headers: ['label', 'nose_x', 'nose_y', 'nose_z', 'nose_v', 'left_shoulder_x', 'left_shoulder_y', 'left_shoulder_z', 'left_shoulder_v', 'right_shoulder_x', 'right_shoulder_y', 'right_shoulder_z', 'right_shoulder_v', 'left_hip_x', 'left_hip_y', 'left_hip_z', 'left_hip_v', 'right_hip_x', 'right_hip_y', 'right_hip_z', 'right_hip_v', 'left_knee_x', 'left_knee_y', 'left_knee_z', 'left_knee_v', 'right_knee_x', 'right_knee_y', 'right_knee_z', 'right_knee_v', 'left_ankle_x', 'left_ankle_y', 'left_ankle_z', 'left_ankle_v', 'right_ankle_x', 'right_ankle_y', 'right_ankle_z', 'right_ankle_v', 'left_heel_x', 'left_heel_y', 'left_heel_z', 'left_heel_v', 'right_heel_x', 'right_heel_y', 'right_heel_z', 'right_heel_v', 'left_foot_index_x', 'left_foot_index_y', 'left_foot_index_z', 'left_foot_index_v', 'right_foot_index_x', 'right_foot_index_y', 'right_foot_index_z', 'right_foot_index_v']\n", "Number of rows: 17907 \n", "Number of columns: 53\n", "\n", "Labels: \n", "L 9114\n", "C 8793\n", "Name: label, dtype: int64\n", "\n", "Missing values: False\n", "\n", "Duplicate Rows : 0\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "df = describe_dataset(\"./err.train.csv\")\n", "sns.countplot(x='label', data=df, palette=\"Set1\") " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.2. Test set" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "sns.countplot(y='label', data=test_df, palette=\"Set1\") " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3.8.13 (conda)", "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.13" }, "orig_nbformat": 4, "vscode": { "interpreter": { "hash": "9260f401923fb5c4108c543a7d176de9733d378b3752e49535ad7c43c2271b65" } } }, "nbformat": 4, "nbformat_minor": 2 }