LabValidation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "926e4eea",
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "from utils import process_subject, run_openpose, json2np, peakdet, get_angle, VERT, MHIP, NECK\n",
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import pickle\n",
    "import subprocess\n",
    "import glob\n",
    "\n",
    "import csv\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from matplotlib.pyplot import figure\n",
    "from scipy.signal import savgol_filter\n",
    "from utils import smooth_ts\n",
    "\n",
    "from scipy.stats import linregress"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ba8dddc",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Get all videos for lab validation\n",
    "video_paths = glob.glob(\"data/lab/*/*.mov\")\n",
    "\n",
    "def get_slug(video_path):\n",
    "    return video_path[9:].replace(\"/\",\"-\").replace(\" \",\"-\").replace(\"(\",\"\").replace(\")\",\"\")\n",
    "for path in video_paths:\n",
    "    print(path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2807bf83",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Run openpose on all videos\n",
    "for path in video_paths:\n",
    "    slug = get_slug(path)[:-4]\n",
    "    run_openpose(path, slug)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1da5254d",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Convert keypoint jsons to numpy arrays\n",
    "os.makedirs(\"data/lab/arrays/\", exist_ok=True)\n",
    "for subjectid in glob.glob(\"data/lab/keypoints/*\"):\n",
    "    target_path = \"data/lab/arrays/{}.npy\".format(subjectid.split(\"/\")[-1])\n",
    "    if os.path.isfile(target_path):\n",
    "        print(\"{} exists\".format(target_path))\n",
    "        continue\n",
    "    res = json2np(subjectid,\"\")\n",
    "    np.save(target_path, res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3704d6f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute metrics on mocap files and compare with openpose videos\n",
    "def mocap_op_comp(path_mot):\n",
    "    rows = []\n",
    "\n",
    "    print(path_mot)\n",
    "\n",
    "    with open(path_mot,\"r\") as f:\n",
    "        lines = f.readlines()\n",
    "        for k, row in enumerate(lines):\n",
    "            if row.strip() == \"endheader\":\n",
    "                break\n",
    "\n",
    "        header = list(map(lambda x: x.strip(), lines[k+1].split(\"\\t\")))\n",
    "        for row in lines[(k+2):]:\n",
    "            variables = list(map(lambda x: float(x.strip()), row.split(\"\\t\")))\n",
    "            rows.append(dict(zip(header,variables)))\n",
    "\n",
    "    df = pd.DataFrame(rows)\n",
    "    print(header)\n",
    "    slug = get_slug(path_mot)[:-4]\n",
    "\n",
    "    res = {\"path_mot\": path_mot}\n",
    "    \n",
    "    framerates = {\n",
    "        \"data/lab/subject 2/STSAsym1 (1).mot\": 239.67,\n",
    "        \"data/lab/subject 2/STS1 (1).mot\": 239.67,\n",
    "        \"data/lab/subject 3/STS1 (2).mot\": 239.67,\n",
    "        \"data/lab/subject 3/STSweakLegs1 (2).mot\": 239.67, \n",
    "        \"data/lab/subject 3/STSAsym1 (2).mot\": 239.67, \n",
    "        \n",
    "    }\n",
    "    framerate = int(framerates.get(path_mot, 60))\n",
    "\n",
    "    try:\n",
    "        results = process_subject(slug,\n",
    "                    framerate = framerates.get(path_mot, 60),\n",
    "                    processed_npy_path=\"data/lab/arrays/\")\n",
    "    except:\n",
    "        return res\n",
    "\n",
    "    oddify = lambda x: x if x%2 ==1 else x+1\n",
    "    \n",
    "    opose = np.load(\"data/lab/arrays/{}.npy\".format(slug))\n",
    "\n",
    "    pelvis_mc = df[\"pelvis_ty\"]\n",
    "    pelvis_mc = savgol_filter(pelvis_mc, oddify(framerate//2), 3)\n",
    "    pelvis_mc = (pelvis_mc - pelvis_mc.min()) / (pelvis_mc.max() - pelvis_mc.min())\n",
    "\n",
    "    filtered = savgol_filter(pelvis_mc, 3, 1)\n",
    "\n",
    "    hip_op = -opose[:,3*8+1]\n",
    "    hip_op = savgol_filter(hip_op, oddify(framerate//2), 3)\n",
    "    hip_op = (hip_op - hip_op.min()) / (hip_op.max() - hip_op.min())\n",
    "\n",
    "    SHIFT = 0 # -0.48 # <- to calculate automatically\n",
    "\n",
    "    plt.plot(df[\"time\"], filtered, label=\"Mocap\")\n",
    "    plt.plot([SHIFT+x/framerate for x in range(opose.shape[0])], savgol_filter(hip_op, oddify(framerate//2), 3), label=\"OpenPose\")\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "    \n",
    "    vert = opose[:,(MHIP*3):(MHIP*3+3)].copy()\n",
    "    vert[:,1] = vert[:,1] - 10\n",
    "    opose = np.hstack([opose.copy(), vert])\n",
    "\n",
    "    framerate_mc = ((df[\"time\"] > 1) * (df[\"time\"] <= 2) ).sum()\n",
    "\n",
    "    trunk_lean_op = savgol_filter(results[\"trunk_lean_ts\"] *180/np.pi, oddify(framerate//2), 3) - 180\n",
    "    trunk_lean_mc = savgol_filter(-df[\"pelvis_tilt\"].to_numpy(), oddify(framerate_mc//2), 3)\n",
    "    start_frame = 160\n",
    "    \n",
    "    peaks_trunk_lean_op = peakdet(trunk_lean_op[20:-50], 10)\n",
    "    peaks_trunk_lean_mc = peakdet(trunk_lean_mc[20:-20], 10)\n",
    "\n",
    "    derv = lambda x: x[1:] - x[:-1]\n",
    "    peaks = peakdet(pelvis_mc, 0.5)\n",
    "    \n",
    "    grid = np.arange(trunk_lean_op.shape[0])/framerate\n",
    "\n",
    "    plt.plot(df[\"time\"], trunk_lean_mc, label=\"Moocap\")\n",
    "    plt.plot(grid[:(-start_frame)], trunk_lean_op[start_frame:], label=\"OpenPose\")\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "    \n",
    "    trunk_lean_vel_op = derv(trunk_lean_op) * framerate\n",
    "    trunk_lean_vel_mc = derv(trunk_lean_mc) * framerate_mc\n",
    "\n",
    "    plt.plot(df[\"time\"][:-1], trunk_lean_vel_mc, label=\"Mocap\")\n",
    "    plt.plot(grid[:(-start_frame-1)], trunk_lean_vel_op[start_frame:], label=\"OpenPose\")\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "    trunk_lean_acc_op = derv(trunk_lean_vel_op) * framerate\n",
    "    trunk_lean_acc_mc = derv(trunk_lean_vel_mc) * framerate_mc\n",
    "    \n",
    "    peak_trunk_lean_acc_op = np.quantile(trunk_lean_acc_op[20:-50], 0.95)\n",
    "    peak_trunk_lean_acc_mc = np.quantile(trunk_lean_acc_mc[20:-20], 0.95)\n",
    "\n",
    "    plt.plot(grid[:(-start_frame-2)], trunk_lean_acc_op[start_frame:], label=\"OpenPose\")\n",
    "    plt.plot(df[\"time\"][:-2], trunk_lean_acc_mc, label=\"Moocap\")\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "    \n",
    "    times_mocap = np.array(df[\"time\"][derv(peaks[0][:,0])])\n",
    "    peaks = peakdet(hip_op, 0.5)\n",
    "    times_openpose = derv(peaks[0][:,0])/framerate\n",
    "    \n",
    "    if len(times_openpose) < 4 or len(times_mocap) < 4:\n",
    "        res.update({\n",
    "            \"mean_diff\": None,\n",
    "        })\n",
    "    else:\n",
    "        res.update({\n",
    "            \"mean_diff\": (times_openpose[:4] - times_mocap[:4]).mean(),\n",
    "            \"time_op\": (times_openpose[:4]).mean(),\n",
    "            \"time_mc\": (times_mocap[:4]).mean(),\n",
    "        })\n",
    "        \n",
    "    print(sorted(peaks_trunk_lean_op[0][:,1])[-2])\n",
    "    print(sorted(peaks_trunk_lean_mc[0][:,1])[-2])\n",
    "    \n",
    "\n",
    "    res.update({\n",
    "        \"trunk_lean_max_mean_op\": sorted(peaks_trunk_lean_op[0][:,1])[-2],\n",
    "        \"trunk_lean_max_mean_mc\": sorted(peaks_trunk_lean_mc[0][:,1])[-2],\n",
    "        \"trunk_lean_op\": peaks_trunk_lean_op[0][:,1],\n",
    "        \"trunk_lean_mc\": peaks_trunk_lean_mc[0][:,1],\n",
    "        \"trunk_lean_acc_op\": peak_trunk_lean_acc_op,\n",
    "        \"trunk_lean_acc_mc\": peak_trunk_lean_acc_mc,\n",
    "    })\n",
    "        \n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0646dbf",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Test on one mocap file\n",
    "mocap_op_comp(\"data/lab/subject 2/STSAsym1 (1).mot\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a3b435ff",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Run on all mocap files \n",
    "video_paths = glob.glob(\"data/lab/*/*.mot\")\n",
    "\n",
    "res = []\n",
    "for video in video_paths:\n",
    "    res.append(mocap_op_comp(video))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "92a5c3a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print out results\n",
    "res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c8d281c8",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Generate plots for the paper\n",
    "res_df = pd.DataFrame(res).dropna()\n",
    "\n",
    "plt.scatter(res_df[\"time_op\"], res_df[\"time_mc\"])\n",
    "plt.show()\n",
    "\n",
    "slope, intercept, r_value, p_value, std_err = linregress(res_df[\"time_op\"], res_df[\"time_mc\"])\n",
    "print(r_value)\n",
    "\n",
    "plt.scatter(res_df[\"trunk_lean_max_mean_op\"], res_df[\"trunk_lean_max_mean_mc\"])\n",
    "plt.show()\n",
    "\n",
    "slope, intercept, r_value, p_value, std_err = linregress(res_df[\"trunk_lean_max_mean_op\"], res_df[\"trunk_lean_max_mean_mc\"])\n",
    "print(r_value)\n",
    "\n",
    "plt.scatter(res_df[\"trunk_lean_acc_mc\"], res_df[\"trunk_lean_acc_op\"])\n",
    "plt.show()\n",
    "\n",
    "slope, intercept, r_value, p_value, std_err = linregress(res_df[\"trunk_lean_acc_op\"], res_df[\"trunk_lean_acc_mc\"])\n",
    "print(r_value)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}