diff --git a/src/augmentations.py b/src/augmentations.py index 4c6aeb6..51d206a 100644 --- a/src/augmentations.py +++ b/src/augmentations.py @@ -36,11 +36,28 @@ def circle_intersection(x0, y0, r0, x1, y1, r1): class MirrorKeypoints: - def __call__(self, sample): + def __call__(self, sample): + if sample.shape[0] == 0: + return sample if random.random() > 0.5: return sample - # flip the keypoints tensor - sample = 1 - sample + + # flip the x coordinates + sample[:, :, 0] *= -1 + + # switch hands (left becomes right and vice versa) + left, right, n = 12, 33, 21 + if isinstance(sample, np.ndarray): # For testing purposes only + sample[:, left:left+n, :], sample[:, right:right+n, :] = sample[: , right:right+n, :], sample[:, left:left+n, :].copy() + else: + sample[:, left:left+n, :], sample[:, right:right+n, :] = sample[: , right:right+n, :], sample[:, left:left+n, :].clone() + + # switch pose keypoints + sample[:, [1, 2], :] = sample[:, [2, 1], :] #eye + sample[:, [3, 4], :] = sample[:, [4, 3], :] #ear + sample[:, [6, 7], :] = sample[:, [7, 6], :] #shoulder + sample[:, [8, 9], :] = sample[:, [9, 8], :] #elbow + sample[:, [10, 11], :] = sample[:, [11, 10], :] #wrist return sample diff --git a/visualizations/visualize_data.ipynb b/visualizations/visualize_data.ipynb index c8ce13f..d2a6cea 100644 --- a/visualizations/visualize_data.ipynb +++ b/visualizations/visualize_data.ipynb @@ -113,7 +113,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -138,7 +138,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -151,9 +151,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "ERROR:root:Video does not exist at path: A!1_20230301111632818161_I3EC3.mp4\n" + ] + }, + { + "ename": "AttributeError", + "evalue": "'NoneType' object has no attribute 'head'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[4], line 9\u001b[0m\n\u001b[0;32m 7\u001b[0m \u001b[38;5;66;03m#Plot the hand keypoints\u001b[39;00m\n\u001b[0;32m 8\u001b[0m df \u001b[38;5;241m=\u001b[39m keypoints_extractor\u001b[38;5;241m.\u001b[39mextract_keypoints_from_video(video_name)\n\u001b[1;32m----> 9\u001b[0m \u001b[43mdf\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mhead\u001b[49m()\n\u001b[0;32m 10\u001b[0m plot_hand_keypoints(df, hand, frame)\n", + "\u001b[1;31mAttributeError\u001b[0m: 'NoneType' object has no attribute 'head'" + ] + } + ], "source": [ "from src.keypoint_extractor import KeypointExtractor\n", "import numpy as np\n", @@ -182,9 +201,38 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "ERROR:root:Video does not exist at path: A!1_20230301111632818161_I3EC3.mp4\n" + ] + }, + { + "ename": "AttributeError", + "evalue": "'NoneType' object has no attribute 'iloc'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[5], line 5\u001b[0m\n\u001b[0;32m 3\u001b[0m plt\u001b[38;5;241m.\u001b[39mxlim(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m0.5\u001b[39m,\u001b[38;5;241m0.5\u001b[39m)\n\u001b[0;32m 4\u001b[0m plt\u001b[38;5;241m.\u001b[39mylim(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m0.5\u001b[39m,\u001b[38;5;241m0.5\u001b[39m)\n\u001b[1;32m----> 5\u001b[0m \u001b[43mplot_hand_keypoints\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mhand\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mframe\u001b[49m\u001b[43m)\u001b[49m\n", + "Cell \u001b[1;32mIn[2], line 8\u001b[0m, in \u001b[0;36mplot_hand_keypoints\u001b[1;34m(dataframe, hand, frame, ret)\u001b[0m\n\u001b[0;32m 5\u001b[0m hand_columns \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marray([i \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m66\u001b[39m \u001b[38;5;241m+\u001b[39m (\u001b[38;5;241m42\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m hand \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mright\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;241m0\u001b[39m), \u001b[38;5;241m108\u001b[39m \u001b[38;5;241m+\u001b[39m (\u001b[38;5;241m42\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m hand \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mright\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;241m0\u001b[39m))])\n\u001b[0;32m 7\u001b[0m \u001b[38;5;66;03m# get the x, y coordinates of the hand keypoints\u001b[39;00m\n\u001b[1;32m----> 8\u001b[0m frame_df \u001b[38;5;241m=\u001b[39m \u001b[43mdataframe\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43miloc\u001b[49m[frame:frame\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m1\u001b[39m, hand_columns]\n\u001b[0;32m 9\u001b[0m hand_coords \u001b[38;5;241m=\u001b[39m frame_df\u001b[38;5;241m.\u001b[39mvalues\u001b[38;5;241m.\u001b[39mreshape(\u001b[38;5;241m21\u001b[39m, \u001b[38;5;241m2\u001b[39m)\n\u001b[0;32m 11\u001b[0m x_coords \u001b[38;5;241m=\u001b[39m hand_coords[:, ::\u001b[38;5;241m2\u001b[39m] \u001b[38;5;66;03m#Even indices\u001b[39;00m\n", + "\u001b[1;31mAttributeError\u001b[0m: 'NoneType' object has no attribute 'iloc'" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "#Plot the NORMALIZED hand keypoints (using bohacek)\n", "df = keypoints_extractor.extract_keypoints_from_video(video_name, normalize=\"bohacek\")\n", @@ -202,7 +250,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -216,22 +264,16 @@ "\n", "def plot_pose_keypoints(dataframe, frame, ret=False, aug=None):\n", " # clear plt\n", - " #plt.clf()\n", - " pose_columns = np.array([i for i in range(34)])\n", + " plt.clf()\n", + " pose_columns = np.array([i for i in range(66)])\n", "\n", " # get the x, y coordinates of the relevant pose keypoints\n", " frame_df = dataframe.iloc[frame:frame+1, pose_columns]\n", - " pose_coords = frame_df.values.reshape(34, 1)\n", + " pose_coords = frame_df.values.reshape(66, 1)\n", "\n", " if aug == \"Z\":\n", " pose_coords = Z_augmentation()(pose_coords, hand_side=\"right\")\n", - " \n", - " pose_coords = pose_coords.reshape(17, 2)\n", - " \n", - " if aug == \"rotate\":\n", - " pose_coords = pose_coords.reshape((1, 17, 2))\n", - " pose_coords = RotateAugmentation()(pose_coords)\n", - " pose_coords = pose_coords.reshape((17, 2))\n", + " pose_coords = pose_coords.reshape(33, 2)\n", "\n", " x_coords = pose_coords[:, ::2] #Even indices\n", " y_coords = -pose_coords[:, 1::2] #Uneven indices (negative because pixels start from the top left)\n", @@ -250,21 +292,190 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "#Set video, hand and frame to display\n", - "video_name = '../data/fingerspelling/data/B!train!2_20230225182123903227_A9NAQ.mp4'\n", - "frame = 5\n", + "video_name = '../data/fingerspelling/data3/A!train!161_20230405093207833310_A1PX4.mp4'\n", + "frame = 2\n", "%reload_ext autoreload" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
 0_x0_y1_x1_y2_x2_y3_x3_y4_x4_y5_x5_y6_x6_y7_x7_y8_x8_y9_x9_y10_x10_y11_x11_y12_x12_y13_x13_y14_x14_y15_x15_y16_x16_y17_x17_y18_x18_y19_x19_y20_x20_y21_x21_y22_x22_y23_x23_y24_x24_y25_x25_y26_x26_y27_x27_y28_x28_y29_x29_y30_x30_y31_x31_y32_x32_y
2301.284752169.724321317.671165146.397014327.098007145.547419336.782417144.621348287.292118147.660956278.756599148.112268271.400032148.810215353.438492151.107287263.839073156.853709321.286964193.427339284.728966196.393261423.722000259.447975211.210232268.782177467.334023433.45816683.428469426.635485418.651848536.651573136.454849280.905132406.456337573.104210147.786150240.942936388.790359557.675171159.203186229.290133385.398331547.494278165.072155245.495396382.671165567.166500232.968140567.738132378.939438804.425182233.850365807.234192374.3906781012.532730237.4629021013.709526378.6030961040.036430236.0162351039.766922354.0171051086.203270251.1120801091.124229
\n" + ], + "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": [ "from src.keypoint_extractor import KeypointExtractor\n", "import numpy as np\n", @@ -280,9 +491,178 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
 0_x0_y1_x1_y2_x2_y3_x3_y4_x4_y5_x5_y6_x6_y7_x7_y8_x8_y9_x9_y10_x10_y11_x11_y12_x12_y13_x13_y14_x14_y15_x15_y16_x16_y17_x17_y18_x18_y19_x19_y20_x20_y21_x21_y22_x22_y23_x23_y24_x24_y25_x25_y26_x26_y27_x27_y28_x28_y29_x29_y30_x30_y31_x31_y32_x32_y
2-0.019018-0.3246690.000241-0.3560020.011320-0.3571430.022702-0.358387-0.035463-0.354304-0.045494-0.353698-0.054140-0.3527600.042277-0.349675-0.063026-0.3419570.004491-0.292832-0.038475-0.2888480.124880-0.204155-0.124880-0.1916180.1761360.029570-0.2750580.0204060.1189210.168176-0.212738-0.1753350.1045880.217138-0.199420-0.2290110.0838250.196414-0.186002-0.2446620.0798390.182739-0.179104-0.2228960.0766340.209163-0.0993080.2099300.0722480.527841-0.0982710.5316140.0669020.807364-0.0940260.8089450.0718530.844306-0.0957260.8439440.0429570.906316-0.0779840.912926
\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "norm_df = keypoints_extractor.extract_keypoints_from_video(video_name, normalize=\"bohacek\")\n", "\n", @@ -299,10 +679,406 @@ ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], + "source": [ + "# Animations" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "norm_df = keypoints_extractor.extract_keypoints_from_video(video_name, normalize=\"bohacek\")\n", "\n", @@ -319,7 +1095,7 @@ " return plot_pose_keypoints(norm_df, 0, ret=True)\n", "\n", "def animate(i):\n", - " return plot_pose_keypoints(norm_df, i, ret=True, aug=True)\n", + " return plot_pose_keypoints(norm_df, i, ret=True, aug=False)\n", "# show animation of the keypoints over time, show one frame every 1000ms and remove the other frames\n", "anim = animation.FuncAnimation(fig, animate, init_func=init, frames=norm_df.shape[0], interval=1000, repeat=False, )\n", "HTML(anim.to_html5_video())\n", @@ -328,9 +1104,618 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig = plt.figure()\n", "ax = plt.axes(xlim=(-0.5, 0.5), ylim=(-0.5, 0.5))\n", @@ -352,9 +1737,167 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "\n", "fig = plt.figure()\n", @@ -375,12 +1918,70 @@ "HTML(anim.to_html5_video())" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Mirror augmentation" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "from src.augmentations import MirrorKeypoints\n", + "import pandas as pd\n", + "mirror = MirrorKeypoints()\n", + "\n", + "norm_df = keypoints_extractor.extract_keypoints_from_video(video_name, normalize=\"bohacek\")\n", + "n = len(norm_df)\n", + "keypoints = norm_df.values.reshape(n, 75, 2)\n", + "mirrored_keypoints = mirror(keypoints)\n", + "mirrored_df = pd.DataFrame(mirrored_keypoints.reshape(n, 150), columns=norm_df.columns)" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 0 0 -5 5 -2 2 -8 8 -7 7 -9 9 -12 12 -11 11 -14 14\n", + " -13 13 -16 16 -15 15 -54 54 -55 55 -56 56 -57 57 -58 58 -59 59\n", + " -60 60 -61 61 -62 62 -63 63 -64 64 -65 65 -66 66 -67 67 -68 68\n", + " -69 69 -70 70 -71 71 -72 72 -73 73 -74 74 -33 33 -34 34 -35 35\n", + " -36 36 -37 37 -38 38 -39 39 -40 40 -41 41 -42 42 -43 43 -44 44\n", + " -45 45 -46 46 -47 47 -48 48 -49 49 -50 50 -51 51 -52 52 -53 53]\n", + " [ 0 0 -5 5 -2 2 -8 8 -7 7 -9 9 -12 12 -11 11 -14 14\n", + " -13 13 -16 16 -15 15 -54 54 -55 55 -56 56 -57 57 -58 58 -59 59\n", + " -60 60 -61 61 -62 62 -63 63 -64 64 -65 65 -66 66 -67 67 -68 68\n", + " -69 69 -70 70 -71 71 -72 72 -73 73 -74 74 -33 33 -34 34 -35 35\n", + " -36 36 -37 37 -38 38 -39 39 -40 40 -41 41 -42 42 -43 43 -44 44\n", + " -45 45 -46 46 -47 47 -48 48 -49 49 -50 50 -51 51 -52 52 -53 53]]\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "seq = np.arange(150 // 2)\n", + "row = np.repeat(seq, 2)\n", + "df = pd.DataFrame(np.array([row, row]), columns = norm_df.columns)\n", + "\n", + "from src.identifiers import LANDMARKS\n", + "mask = [\"\" + str(landmark) + \"_\" + str(axis) for landmark in list(LANDMARKS.values()) for axis in ['x', 'y']]\n", + "filtered_df = df[mask]\n", + "filtered_kp = filtered_df.values.reshape((2, 54, 2))\n", + "\n", + "mirror = MirrorKeypoints()\n", + "mirrored_kp = mirror(filtered_kp)\n", + "print(mirrored_kp.reshape(2, 108))" + ] }, { "cell_type": "code",