check_posture_analysis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sitting Posture Detection\n",
    "\n",
    "Group Member:\n",
    "- Christoffer Edbert Karuniawan (2602082944)\n",
    "- Jason Nicholas (2602133043)\n",
    "- Kenzie Raditya Tirtarahardja (2602153581)\n",
    "----\n",
    "\n",
    "In this notebook, we will analyze the accuracy of our model. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importing Library\n",
    "\n",
    "We use cv2 from OpenCV and MediaPipe for our model. We also import other useful library for implementation and visualization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import cv2\n",
    "import time\n",
    "import math as m\n",
    "import mediapipe as mp\n",
    "import numpy as np\n",
    "import seaborn as sn\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initializing mediapipe selfie implementation class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "mp_pose = mp.solutions.pose\n",
    "pose = mp_pose.Pose()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Angle Calculator Function\n",
    "\n",
    "This function is very important to calculate the angle of the body posture, which is the fundamental for determining good or bad posture.\n",
    "\n",
    "<img src=\"ilustration/angle_ilustration.jpg\" align=\"middle\" width=\"500\" height=\"600\">\n",
    "\n",
    "We can see these points as vectors and try to compute $\\theta$.\n",
    "\n",
    "$$\n",
    "\\theta = \\arccos (\\frac{\\vec{P_{12}}.\\vec{P_{13}}}{|\\vec{P_{12}}|.|\\vec{P_{13}}|})\n",
    "$$\n",
    "\n",
    "Note that $P_3$ can be any point, as long as it is verticaly aligned (have the same x-coordinate) with $P_1$. For simplicity, we will assume that $P_3$ has a value y of $0$.\n",
    "Hence,\n",
    "\n",
    "$$\n",
    "\\theta = \\arccos (\\frac{y_1^2 - y_1.y_2}{y_1\\sqrt{(x_2 - x_1)^2 + (y_2 - y_1)^2}})\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "def angle(x1, y1, x2, y2):\n",
    "    a = (y2 - y1) * (-y1)\n",
    "    b = (m.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2) * y1)\n",
    "    if b != 0:\n",
    "        theta = m.acos(a / b)\n",
    "        degree = int(180 / m.pi) * theta\n",
    "    else:\n",
    "        degree = 0\n",
    "    return degree"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Posture Checker Function\n",
    "\n",
    "We pass the directory and filename of the test image. We then determine whether the posture is good or bad by calculating the neck inclination (by computing the angle between left shoulder and left ear) and torso inclination (by computing the angle between left hip and left shoulder)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def checkPosture(dir, filename):\n",
    "    image = cv2.imread(dir+\"/\"+filename)\n",
    "    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
    "\n",
    "    h, w = image.shape[:2]\n",
    "\n",
    "    keypoints = pose.process(image)\n",
    "    \n",
    "    lm = keypoints.pose_landmarks\n",
    "    lmPose = mp_pose.PoseLandmark\n",
    "\n",
    "    if lm == None:\n",
    "        return -1\n",
    "    \n",
    "    # Acquire landmark coordinates\n",
    "    # Left Shoulder\n",
    "    left_shoulder_x = int(lm.landmark[lmPose.LEFT_SHOULDER].x * w)\n",
    "    left_shoulder_y = int(lm.landmark[lmPose.LEFT_SHOULDER].y * w)\n",
    "    # Left Ear\n",
    "    left_ear_x = int(lm.landmark[lmPose.LEFT_EAR].x * w)\n",
    "    left_ear_y = int(lm.landmark[lmPose.LEFT_EAR].y * w)\n",
    "    # Left hip\n",
    "    left_hip_x = int(lm.landmark[lmPose.LEFT_HIP].x * w)\n",
    "    left_hip_y = int(lm.landmark[lmPose.LEFT_HIP].y * w)\n",
    "\n",
    "    # Calculate angles\n",
    "    neck_inclination = angle(left_shoulder_x, left_shoulder_y, left_ear_x, left_ear_y)\n",
    "    torso_inclination = angle(left_hip_x, left_hip_y, left_shoulder_x, left_shoulder_y)\n",
    "\n",
    "    if neck_inclination < 25 and torso_inclination < 8:\n",
    "        return 1\n",
    "    return 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Testing the Dataset\n",
    "\n",
    "There are 4 directory, 2 of them contain bad posture pictures and 2 of them contain good posture pictures. We will test our model for all of them, and create a confusion matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Directory for all data set\n",
    "bad_directory1 = \"test_dataset/data/bad/1\"\n",
    "bad_directory2 = \"test_dataset/data/bad/2\"\n",
    "good_directory1 = \"test_dataset/data/good/1\"\n",
    "good_directory2 = \"test_dataset/data/good/2\"\n",
    "\n",
    "# Declare confusion matrix (0: bad, 1: good)\n",
    "conf_mat = np.zeros([2, 2], dtype=int)\n",
    "\n",
    "miss_scan = 0\n",
    "\n",
    "# Test first bad posture folder\n",
    "for filename in os.listdir(bad_directory1):\n",
    "    if not filename.endswith('.jpg'):\n",
    "        continue\n",
    "    \n",
    "    if checkPosture(bad_directory1, filename) == 0:\n",
    "        conf_mat[0][0] += 1\n",
    "    elif checkPosture(bad_directory1, filename) == 1:\n",
    "        conf_mat[0][1] += 1\n",
    "    else:\n",
    "        miss_scan += 1\n",
    "\n",
    "# Test second bad posture folder\n",
    "for filename in os.listdir(bad_directory2):\n",
    "    if not filename.endswith('.jpg'):\n",
    "        continue\n",
    "\n",
    "    if checkPosture(bad_directory2, filename) == 0:\n",
    "        conf_mat[0][0] += 1\n",
    "    elif checkPosture(bad_directory2, filename) == 1:\n",
    "        conf_mat[0][1] += 1\n",
    "    else:\n",
    "        miss_scan += 1\n",
    "\n",
    "# Test first good posture folder\n",
    "for filename in os.listdir(good_directory1):\n",
    "    if not filename.endswith('.jpg'):\n",
    "        continue\n",
    "\n",
    "    if checkPosture(good_directory1, filename) == 0:\n",
    "        conf_mat[1][0] += 1\n",
    "    elif checkPosture(good_directory1, filename) == 1:\n",
    "        conf_mat[1][1] += 1\n",
    "    else:\n",
    "        miss_scan += 1\n",
    "\n",
    "# Test second good posture folder\n",
    "for filename in os.listdir(good_directory2):\n",
    "    if not filename.endswith('.jpg'):\n",
    "\n",
    "        continue\n",
    "    if checkPosture(good_directory2, filename) == 0:\n",
    "        conf_mat[1][0] += 1\n",
    "    elif checkPosture(good_directory2, filename) == 1:\n",
    "        conf_mat[1][1] += 1\n",
    "    else:\n",
    "        miss_scan += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting the Confusion Matrix\n",
    "\n",
    "Plotting the confusion matrix using the seaborn library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(0.5, 1.0, 'Confusion Matrix')]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_con = pd.DataFrame(conf_mat, range(2), range(2))\n",
    "\n",
    "df_con = df_con.set_axis([\"Bad\", \"Good\"], axis=\"columns\")\n",
    "df_con = df_con.set_axis([\"Bad\", \"Good\"], axis=\"index\")\n",
    "\n",
    "sn.set(font_scale=1.4)\n",
    "sn.heatmap(df_con, annot=True, annot_kws={\"size\": 16}).set(title=\"Confusion Matrix\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Computing Accuracy\n",
    "\n",
    "We can compute the accuracy our model from our confusion matrix with the formula\n",
    "\n",
    "$$\n",
    "TP+TN \\over TP+TN+FP+FN\n",
    "$$\n",
    "\n",
    "Note:\n",
    "- $TP$: True Positive\n",
    "- $TN$: True Negative\n",
    "- $FP$: False Positive\n",
    "- $FN$: False Negative"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy for our model based on our dataset: 94.137%\n"
     ]
    }
   ],
   "source": [
    "Accuracy = (conf_mat[0][0]+conf_mat[1][1])/(conf_mat[0][0]+conf_mat[0][1]+conf_mat[1][1]+conf_mat[1][0])\n",
    "\n",
    "print(f\"Accuracy for our model based on our dataset: {round(Accuracy*100, 3)}%\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}