{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import sys\n", "sys.path.insert(0,'..')\n", "from src.keypoint_extractor import KeypointExtractor\n", "\n", "# reload modules\n", "%load_ext autoreload" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "video_name = '../data/fingerspelling/data/Z!train!26_20230323144550450800_2RIPN.mp4'\n" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "# extract keypoints\n", "keypoint_extractor = KeypointExtractor()" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import numpy as np\n", "from IPython.display import HTML\n", "from base64 import b64encode\n", "import mediapy as media\n", "%matplotlib inline\n", "\n", "# Define the frames per second (fps) and duration of the video\n", "fps = 25\n", "duration = 10\n", "\n", "# Create a dummy video of random noise\n", "_, video_frames = keypoint_extractor.extract_keypoints_from_video(video_name, normalize=\"minmax\", draw=True)\n", "\n", "# Convert the video to a numpy array\n", "video = np.array(video_frames)\n", "media.show_video(video, height=400, codec='gif', fps=4)\n", "\n", "# write the video to a file\n", "media.write_video('test.mp4',video, fps=10)\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "ename": "FileNotFoundError", "evalue": "[Errno 2] No such file or directory: 'models/spoter_40.pth'", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", "Cell \u001b[0;32mIn[5], line 6\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mtorch\u001b[39;00m\n\u001b[1;32m 5\u001b[0m spoter_model \u001b[39m=\u001b[39m SPOTER(num_classes\u001b[39m=\u001b[39m\u001b[39m5\u001b[39m, hidden_dim\u001b[39m=\u001b[39m\u001b[39mlen\u001b[39m(LANDMARKS) \u001b[39m*\u001b[39m\u001b[39m2\u001b[39m)\n\u001b[0;32m----> 6\u001b[0m spoter_model\u001b[39m.\u001b[39mload_state_dict(torch\u001b[39m.\u001b[39;49mload(\u001b[39m'\u001b[39;49m\u001b[39mmodels/spoter_40.pth\u001b[39;49m\u001b[39m'\u001b[39;49m))\n", "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/torch/serialization.py:771\u001b[0m, in \u001b[0;36mload\u001b[0;34m(f, map_location, pickle_module, weights_only, **pickle_load_args)\u001b[0m\n\u001b[1;32m 768\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39m'\u001b[39m\u001b[39mencoding\u001b[39m\u001b[39m'\u001b[39m \u001b[39mnot\u001b[39;00m \u001b[39min\u001b[39;00m pickle_load_args\u001b[39m.\u001b[39mkeys():\n\u001b[1;32m 769\u001b[0m pickle_load_args[\u001b[39m'\u001b[39m\u001b[39mencoding\u001b[39m\u001b[39m'\u001b[39m] \u001b[39m=\u001b[39m \u001b[39m'\u001b[39m\u001b[39mutf-8\u001b[39m\u001b[39m'\u001b[39m\n\u001b[0;32m--> 771\u001b[0m \u001b[39mwith\u001b[39;00m _open_file_like(f, \u001b[39m'\u001b[39;49m\u001b[39mrb\u001b[39;49m\u001b[39m'\u001b[39;49m) \u001b[39mas\u001b[39;00m opened_file:\n\u001b[1;32m 772\u001b[0m \u001b[39mif\u001b[39;00m _is_zipfile(opened_file):\n\u001b[1;32m 773\u001b[0m \u001b[39m# The zipfile reader is going to advance the current file position.\u001b[39;00m\n\u001b[1;32m 774\u001b[0m \u001b[39m# If we want to actually tail call to torch.jit.load, we need to\u001b[39;00m\n\u001b[1;32m 775\u001b[0m \u001b[39m# reset back to the original position.\u001b[39;00m\n\u001b[1;32m 776\u001b[0m orig_position \u001b[39m=\u001b[39m opened_file\u001b[39m.\u001b[39mtell()\n", "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/torch/serialization.py:270\u001b[0m, in \u001b[0;36m_open_file_like\u001b[0;34m(name_or_buffer, mode)\u001b[0m\n\u001b[1;32m 268\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_open_file_like\u001b[39m(name_or_buffer, mode):\n\u001b[1;32m 269\u001b[0m \u001b[39mif\u001b[39;00m _is_path(name_or_buffer):\n\u001b[0;32m--> 270\u001b[0m \u001b[39mreturn\u001b[39;00m _open_file(name_or_buffer, mode)\n\u001b[1;32m 271\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 272\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39m'\u001b[39m\u001b[39mw\u001b[39m\u001b[39m'\u001b[39m \u001b[39min\u001b[39;00m mode:\n", "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/torch/serialization.py:251\u001b[0m, in \u001b[0;36m_open_file.__init__\u001b[0;34m(self, name, mode)\u001b[0m\n\u001b[1;32m 250\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m__init__\u001b[39m(\u001b[39mself\u001b[39m, name, mode):\n\u001b[0;32m--> 251\u001b[0m \u001b[39msuper\u001b[39m(_open_file, \u001b[39mself\u001b[39m)\u001b[39m.\u001b[39m\u001b[39m__init__\u001b[39m(\u001b[39mopen\u001b[39;49m(name, mode))\n", "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'models/spoter_40.pth'" ] } ], "source": [ "from src.model import SPOTER\n", "from src.identifiers import LANDMARKS\n", "import torch\n", "\n", "spoter_model = SPOTER(num_classes=5, hidden_dim=len(LANDMARKS) *2)\n", "spoter_model.load_state_dict(torch.load('models/spoter_40.pth'))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# get average number of frames in test set\n", "from src.keypoint_extractor import KeypointExtractor\n", "from src.datasets.finger_spelling_dataset import FingerSpellingDataset\n", "from src.identifiers import LANDMARKS\n", "import numpy as np\n", "\n", "keypoints_extractor = KeypointExtractor(\"../data/fingerspelling/data/\")\n", "test_set = FingerSpellingDataset(\"../data/fingerspelling/data/\", keypoints_extractor, keypoints_identifier=LANDMARKS, subset=\"val\")\n", "\n", "frames = []\n", "labels = []\n", "for sample, label in test_set:\n", " frames.append(sample.shape[0])\n", " labels.append(label)\n", "\n", "print(np.mean(frames))\n", "# get label frequency in the labels list\n", "from collections import Counter\n", "\n", "counter = Counter(labels)\n", "print(counter)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Hand keypoint visualization" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "\n", "def plot_hand_keypoints(dataframe, hand, frame, ret=False):\n", " plt.clf()\n", " hand_columns = np.array([i for i in range(66 + (42 if hand == \"right\" else 0), 108 + (42 if hand == \"right\" else 0))])\n", " \n", " # get the x, y coordinates of the hand keypoints\n", " frame_df = dataframe.iloc[frame:frame+1, hand_columns]\n", " hand_coords = frame_df.values.reshape(21, 2)\n", " \n", " x_coords = hand_coords[:, ::2] #Even indices\n", " y_coords = -hand_coords[:, 1::2] #Uneven indices (negative because pixels start from the top left)\n", " if ret:\n", " return plt.scatter(x_coords, y_coords, c='b')\n", " #Plot the keypoints\n", " plt.scatter(x_coords, y_coords)\n", " return frame_df.style" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#Set video, hand and frame to display\n", "video_name = 'A!1_20230301111632818161_I3EC3.mp4'\n", "hand = \"right\"\n", "frame = 5\n", "%reload_ext autoreload" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "INFO: Created TensorFlow Lite XNNPACK delegate for CPU.\n" ] }, { "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", "
 54_x54_y55_x55_y56_x56_y57_x57_y58_x58_y59_x59_y60_x60_y61_x61_y62_x62_y63_x63_y64_x64_y65_x65_y66_x66_y67_x67_y68_x68_y69_x69_y70_x70_y71_x71_y72_x72_y73_x73_y74_x74_y
5206.460323241.187210230.258865224.058051240.719643194.888663243.763103176.291513245.644760160.364571222.654018164.100680244.763489159.433722241.298084180.507073232.752953187.535305211.368618164.291081237.624207160.842934232.236347185.703449221.870766190.408745200.001240168.123393226.508846165.884171221.417446190.005541210.547810194.531407188.253899175.198359212.090034172.334862210.177135188.840246200.824184193.307934
\n" ], "text/plain": [ "" ] }, "execution_count": 5, "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", "\n", "#Extract keypoints from requested video\n", "keypoints_extractor = KeypointExtractor(\"../data/fingerspelling/data/\")\n", "\n", "#Plot the hand keypoints\n", "df = keypoints_extractor.extract_keypoints_from_video(video_name)\n", "df.head()\n", "plot_hand_keypoints(df, hand, frame)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "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", "
 54_x54_y55_x55_y56_x56_y57_x57_y58_x58_y59_x59_y60_x60_y61_x61_y62_x62_y63_x63_y64_x64_y65_x65_y66_x66_y67_x67_y68_x68_y69_x69_y70_x70_y71_x71_y72_x72_y73_x73_y74_x74_y
5-0.1827640.5000000.2319100.2904780.414183-0.0663190.467213-0.2937970.500000-0.4886140.099401-0.4429140.484644-0.5000000.424262-0.2422330.275368-0.156264-0.097240-0.4405850.360247-0.4827630.266367-0.1786710.085753-0.121117-0.295310-0.3937090.166569-0.4210990.077854-0.126049-0.111542-0.070689-0.500000-0.307169-0.084670-0.342195-0.118001-0.140303-0.280971-0.085654
\n" ], "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": [ "#Plot the NORMALIZED hand keypoints (using minxmax)\n", "df = keypoints_extractor.extract_keypoints_from_video(video_name, normalize=\"minmax\")\n", "plt.xlim(-0.5,0.5)\n", "plt.ylim(-0.5,0.5)\n", "plot_hand_keypoints(df, hand, frame)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "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", "
 54_x54_y55_x55_y56_x56_y57_x57_y58_x58_y59_x59_y60_x60_y61_x61_y62_x62_y63_x63_y64_x64_y65_x65_y66_x66_y67_x67_y68_x68_y69_x69_y70_x70_y71_x71_y72_x72_y73_x73_y74_x74_y
5-0.1069170.4166670.1356670.2420650.242297-0.0552660.273319-0.2448310.292500-0.4071780.058149-0.3690950.283517-0.4166670.248193-0.2018610.161090-0.130220-0.056886-0.3671540.210744-0.4023020.155824-0.1488930.050165-0.100931-0.172756-0.3280910.097442-0.3509160.045545-0.105041-0.065252-0.058907-0.292500-0.255974-0.049532-0.285162-0.069031-0.116919-0.164368-0.071379
\n" ], "text/plain": [ "" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "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", "plt.xlim(-0.5,0.5)\n", "plt.ylim(-0.5,0.5)\n", "plot_hand_keypoints(df, hand, frame)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Pose keypoint visualization" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "\n", "import sys\n", "sys.path.insert(0,'..')\n", "from src.augmentations import Z_augmentation\n", "from src.keypoint_extractor import KeypointExtractor\n", "\n", "\n", "def plot_pose_keypoints(dataframe, frame, ret=False, aug=False):\n", " # clear plt\n", " plt.clf()\n", " pose_columns = np.array([i for i in range(34)])\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", "\n", " if aug:\n", " pose_coords = Z_augmentation()(pose_coords, hand_side=\"right\")\n", " pose_coords = pose_coords.reshape(17, 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", "\n", " # return a scatter plot of the pose keypoints\n", " if ret:\n", " plt.xlim(-0.5,0.5)\n", " plt.ylim(-0.5,0.5)\n", " return plt.scatter(x_coords, y_coords, c='r')\n", "\n", " plt.xlim(-0.5,0.5)\n", " plt.ylim(-0.5,0.5)\n", " plt.scatter(x_coords, y_coords)\n", " return frame_df.style\n" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "#Set video, hand and frame to display\n", "video_name = 'Z!26_20230313174809489724_CGG2F.mp4'\n", "frame = 2\n", "%reload_ext autoreload" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "INFO: Created TensorFlow Lite XNNPACK delegate for CPU.\n" ] }, { "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", "
 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_y
2314.597130203.601093333.606339177.124128343.284836178.611474353.475113180.199170299.696846173.968377287.641029173.626041276.889381173.728795369.040298195.947542261.266518190.308652332.395744235.577416290.494938233.121829437.649574348.909016172.417698350.768766524.350166508.146744121.787348523.435078461.661911373.101339122.718906719.282742
\n" ], "text/plain": [ "" ] }, "execution_count": 3, "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", "\n", "#Extract keypoints from requested video\n", "keypoints_extractor = KeypointExtractor(\"../data/fingerspelling/data/\")\n", "\n", "#Plot the hand keypoints\n", "df = keypoints_extractor.extract_keypoints_from_video(video_name)\n", "df.head()\n", "plot_pose_keypoints(df, frame)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "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", "
 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_y
20.009014-0.3302240.026931-0.3587450.036054-0.3571430.045658-0.355433-0.005030-0.362144-0.016393-0.362513-0.026527-0.3624020.060329-0.338468-0.041253-0.3445430.025790-0.295779-0.013703-0.2984240.124997-0.173699-0.124997-0.1716950.206716-0.002168-0.1727180.0143000.147630-0.147639-0.1718400.225267
\n" ], "text/plain": [ "" ] }, "execution_count": 4, "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", "plt.xlim(-0.5,0.5)\n", "plt.ylim(-0.5,0.5)\n", "plot_pose_keypoints(norm_df, frame)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "execution_count": 5, "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", "# create animation of the keypoints over time\n", "import matplotlib.pyplot as plt\n", "import matplotlib.animation as animation\n", "from IPython.display import HTML\n", "\n", "fig = plt.figure()\n", "plt.xlim(-0.5, 0.5)\n", "plt.ylim(-0.5, 0.5)\n", "\n", "def init():\n", " 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", "# 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", "\n" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "ename": "NameError", "evalue": "name 'plot_hand_keypoints' is not defined", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", "Cell \u001b[0;32mIn[6], line 16\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[39m# show animation of the keypoints over time, show one frame every 1000ms and remove the other frames\u001b[39;00m\n\u001b[1;32m 15\u001b[0m anim \u001b[39m=\u001b[39m animation\u001b[39m.\u001b[39mFuncAnimation(fig, animate_hand, init_func\u001b[39m=\u001b[39minit_hand, frames\u001b[39m=\u001b[39mnorm_df\u001b[39m.\u001b[39mshape[\u001b[39m0\u001b[39m], interval\u001b[39m=\u001b[39m\u001b[39m1000\u001b[39m, repeat\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m, )\n\u001b[0;32m---> 16\u001b[0m HTML(anim\u001b[39m.\u001b[39;49mto_html5_video())\n", "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/animation.py:1288\u001b[0m, in \u001b[0;36mAnimation.to_html5_video\u001b[0;34m(self, embed_limit)\u001b[0m\n\u001b[1;32m 1284\u001b[0m Writer \u001b[39m=\u001b[39m writers[mpl\u001b[39m.\u001b[39mrcParams[\u001b[39m'\u001b[39m\u001b[39manimation.writer\u001b[39m\u001b[39m'\u001b[39m]]\n\u001b[1;32m 1285\u001b[0m writer \u001b[39m=\u001b[39m Writer(codec\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mh264\u001b[39m\u001b[39m'\u001b[39m,\n\u001b[1;32m 1286\u001b[0m bitrate\u001b[39m=\u001b[39mmpl\u001b[39m.\u001b[39mrcParams[\u001b[39m'\u001b[39m\u001b[39manimation.bitrate\u001b[39m\u001b[39m'\u001b[39m],\n\u001b[1;32m 1287\u001b[0m fps\u001b[39m=\u001b[39m\u001b[39m1000.\u001b[39m \u001b[39m/\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_interval)\n\u001b[0;32m-> 1288\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49msave(\u001b[39mstr\u001b[39;49m(path), writer\u001b[39m=\u001b[39;49mwriter)\n\u001b[1;32m 1289\u001b[0m \u001b[39m# Now open and base64 encode.\u001b[39;00m\n\u001b[1;32m 1290\u001b[0m vid64 \u001b[39m=\u001b[39m base64\u001b[39m.\u001b[39mencodebytes(path\u001b[39m.\u001b[39mread_bytes())\n", "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/animation.py:1090\u001b[0m, in \u001b[0;36mAnimation.save\u001b[0;34m(self, filename, writer, fps, dpi, codec, bitrate, extra_args, metadata, extra_anim, savefig_kwargs, progress_callback)\u001b[0m\n\u001b[1;32m 1085\u001b[0m \u001b[39mwith\u001b[39;00m mpl\u001b[39m.\u001b[39mrc_context({\u001b[39m'\u001b[39m\u001b[39msavefig.bbox\u001b[39m\u001b[39m'\u001b[39m: \u001b[39mNone\u001b[39;00m}), \\\n\u001b[1;32m 1086\u001b[0m writer\u001b[39m.\u001b[39msaving(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_fig, filename, dpi), \\\n\u001b[1;32m 1087\u001b[0m cbook\u001b[39m.\u001b[39m_setattr_cm(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_fig\u001b[39m.\u001b[39mcanvas,\n\u001b[1;32m 1088\u001b[0m _is_saving\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m, manager\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m):\n\u001b[1;32m 1089\u001b[0m \u001b[39mfor\u001b[39;00m anim \u001b[39min\u001b[39;00m all_anim:\n\u001b[0;32m-> 1090\u001b[0m anim\u001b[39m.\u001b[39;49m_init_draw() \u001b[39m# Clear the initial frame\u001b[39;00m\n\u001b[1;32m 1091\u001b[0m frame_number \u001b[39m=\u001b[39m \u001b[39m0\u001b[39m\n\u001b[1;32m 1092\u001b[0m \u001b[39m# TODO: Currently only FuncAnimation has a save_count\u001b[39;00m\n\u001b[1;32m 1093\u001b[0m \u001b[39m# attribute. Can we generalize this to all Animations?\u001b[39;00m\n", "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/animation.py:1750\u001b[0m, in \u001b[0;36mFuncAnimation._init_draw\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1748\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_draw_frame(frame_data)\n\u001b[1;32m 1749\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m-> 1750\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_drawn_artists \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_init_func()\n\u001b[1;32m 1751\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_blit:\n\u001b[1;32m 1752\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_drawn_artists \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n", "Cell \u001b[0;32mIn[6], line 9\u001b[0m, in \u001b[0;36minit_hand\u001b[0;34m()\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39minit_hand\u001b[39m():\n\u001b[0;32m----> 9\u001b[0m \u001b[39mreturn\u001b[39;00m plot_hand_keypoints(norm_df, \u001b[39m\"\u001b[39m\u001b[39mright\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39m0\u001b[39m, ret\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m)\n", "\u001b[0;31mNameError\u001b[0m: name 'plot_hand_keypoints' is not defined" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Error in callback (for post_execute):\n" ] }, { "ename": "NameError", "evalue": "name 'plot_hand_keypoints' is not defined", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/pyplot.py:120\u001b[0m, in \u001b[0;36m_draw_all_if_interactive\u001b[0;34m()\u001b[0m\n\u001b[1;32m 118\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_draw_all_if_interactive\u001b[39m():\n\u001b[1;32m 119\u001b[0m \u001b[39mif\u001b[39;00m matplotlib\u001b[39m.\u001b[39mis_interactive():\n\u001b[0;32m--> 120\u001b[0m draw_all()\n", "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/_pylab_helpers.py:132\u001b[0m, in \u001b[0;36mGcf.draw_all\u001b[0;34m(cls, force)\u001b[0m\n\u001b[1;32m 130\u001b[0m \u001b[39mfor\u001b[39;00m manager \u001b[39min\u001b[39;00m \u001b[39mcls\u001b[39m\u001b[39m.\u001b[39mget_all_fig_managers():\n\u001b[1;32m 131\u001b[0m \u001b[39mif\u001b[39;00m force \u001b[39mor\u001b[39;00m manager\u001b[39m.\u001b[39mcanvas\u001b[39m.\u001b[39mfigure\u001b[39m.\u001b[39mstale:\n\u001b[0;32m--> 132\u001b[0m manager\u001b[39m.\u001b[39;49mcanvas\u001b[39m.\u001b[39;49mdraw_idle()\n", "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/backend_bases.py:2082\u001b[0m, in \u001b[0;36mFigureCanvasBase.draw_idle\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 2080\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_is_idle_drawing:\n\u001b[1;32m 2081\u001b[0m \u001b[39mwith\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_idle_draw_cntx():\n\u001b[0;32m-> 2082\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mdraw(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n", "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/backends/backend_agg.py:400\u001b[0m, in \u001b[0;36mFigureCanvasAgg.draw\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 396\u001b[0m \u001b[39m# Acquire a lock on the shared font cache.\u001b[39;00m\n\u001b[1;32m 397\u001b[0m \u001b[39mwith\u001b[39;00m RendererAgg\u001b[39m.\u001b[39mlock, \\\n\u001b[1;32m 398\u001b[0m (\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mtoolbar\u001b[39m.\u001b[39m_wait_cursor_for_draw_cm() \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mtoolbar\n\u001b[1;32m 399\u001b[0m \u001b[39melse\u001b[39;00m nullcontext()):\n\u001b[0;32m--> 400\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mfigure\u001b[39m.\u001b[39;49mdraw(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mrenderer)\n\u001b[1;32m 401\u001b[0m \u001b[39m# A GUI class may be need to update a window using this draw, so\u001b[39;00m\n\u001b[1;32m 402\u001b[0m \u001b[39m# don't forget to call the superclass.\u001b[39;00m\n\u001b[1;32m 403\u001b[0m \u001b[39msuper\u001b[39m()\u001b[39m.\u001b[39mdraw()\n", "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/artist.py:95\u001b[0m, in \u001b[0;36m_finalize_rasterization..draw_wrapper\u001b[0;34m(artist, renderer, *args, **kwargs)\u001b[0m\n\u001b[1;32m 93\u001b[0m \u001b[39m@wraps\u001b[39m(draw)\n\u001b[1;32m 94\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mdraw_wrapper\u001b[39m(artist, renderer, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[0;32m---> 95\u001b[0m result \u001b[39m=\u001b[39m draw(artist, renderer, \u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 96\u001b[0m \u001b[39mif\u001b[39;00m renderer\u001b[39m.\u001b[39m_rasterizing:\n\u001b[1;32m 97\u001b[0m renderer\u001b[39m.\u001b[39mstop_rasterizing()\n", "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/artist.py:72\u001b[0m, in \u001b[0;36mallow_rasterization..draw_wrapper\u001b[0;34m(artist, renderer)\u001b[0m\n\u001b[1;32m 69\u001b[0m \u001b[39mif\u001b[39;00m artist\u001b[39m.\u001b[39mget_agg_filter() \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 70\u001b[0m renderer\u001b[39m.\u001b[39mstart_filter()\n\u001b[0;32m---> 72\u001b[0m \u001b[39mreturn\u001b[39;00m draw(artist, renderer)\n\u001b[1;32m 73\u001b[0m \u001b[39mfinally\u001b[39;00m:\n\u001b[1;32m 74\u001b[0m \u001b[39mif\u001b[39;00m artist\u001b[39m.\u001b[39mget_agg_filter() \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n", "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/figure.py:3150\u001b[0m, in \u001b[0;36mFigure.draw\u001b[0;34m(self, renderer)\u001b[0m\n\u001b[1;32m 3147\u001b[0m \u001b[39mfinally\u001b[39;00m:\n\u001b[1;32m 3148\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mstale \u001b[39m=\u001b[39m \u001b[39mFalse\u001b[39;00m\n\u001b[0;32m-> 3150\u001b[0m DrawEvent(\u001b[39m\"\u001b[39;49m\u001b[39mdraw_event\u001b[39;49m\u001b[39m\"\u001b[39;49m, \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mcanvas, renderer)\u001b[39m.\u001b[39;49m_process()\n", "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/backend_bases.py:1263\u001b[0m, in \u001b[0;36mEvent._process\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1261\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_process\u001b[39m(\u001b[39mself\u001b[39m):\n\u001b[1;32m 1262\u001b[0m \u001b[39m \u001b[39m\u001b[39m\"\"\"Generate an event with name ``self.name`` on ``self.canvas``.\"\"\"\u001b[39;00m\n\u001b[0;32m-> 1263\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mcanvas\u001b[39m.\u001b[39;49mcallbacks\u001b[39m.\u001b[39;49mprocess(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mname, \u001b[39mself\u001b[39;49m)\n", "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/cbook/__init__.py:309\u001b[0m, in \u001b[0;36mCallbackRegistry.process\u001b[0;34m(self, s, *args, **kwargs)\u001b[0m\n\u001b[1;32m 307\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m \u001b[39mas\u001b[39;00m exc:\n\u001b[1;32m 308\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mexception_handler \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m--> 309\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mexception_handler(exc)\n\u001b[1;32m 310\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 311\u001b[0m \u001b[39mraise\u001b[39;00m\n", "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/cbook/__init__.py:96\u001b[0m, in \u001b[0;36m_exception_printer\u001b[0;34m(exc)\u001b[0m\n\u001b[1;32m 94\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_exception_printer\u001b[39m(exc):\n\u001b[1;32m 95\u001b[0m \u001b[39mif\u001b[39;00m _get_running_interactive_framework() \u001b[39min\u001b[39;00m [\u001b[39m\"\u001b[39m\u001b[39mheadless\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39mNone\u001b[39;00m]:\n\u001b[0;32m---> 96\u001b[0m \u001b[39mraise\u001b[39;00m exc\n\u001b[1;32m 97\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 98\u001b[0m traceback\u001b[39m.\u001b[39mprint_exc()\n", "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/cbook/__init__.py:304\u001b[0m, in \u001b[0;36mCallbackRegistry.process\u001b[0;34m(self, s, *args, **kwargs)\u001b[0m\n\u001b[1;32m 302\u001b[0m \u001b[39mif\u001b[39;00m func \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 303\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m--> 304\u001b[0m func(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 305\u001b[0m \u001b[39m# this does not capture KeyboardInterrupt, SystemExit,\u001b[39;00m\n\u001b[1;32m 306\u001b[0m \u001b[39m# and GeneratorExit\u001b[39;00m\n\u001b[1;32m 307\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m \u001b[39mas\u001b[39;00m exc:\n", "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/animation.py:904\u001b[0m, in \u001b[0;36mAnimation._start\u001b[0;34m(self, *args)\u001b[0m\n\u001b[1;32m 901\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_fig\u001b[39m.\u001b[39mcanvas\u001b[39m.\u001b[39mmpl_disconnect(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_first_draw_id)\n\u001b[1;32m 903\u001b[0m \u001b[39m# Now do any initial draw\u001b[39;00m\n\u001b[0;32m--> 904\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_init_draw()\n\u001b[1;32m 906\u001b[0m \u001b[39m# Add our callback for stepping the animation and\u001b[39;00m\n\u001b[1;32m 907\u001b[0m \u001b[39m# actually start the event_source.\u001b[39;00m\n\u001b[1;32m 908\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mevent_source\u001b[39m.\u001b[39madd_callback(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_step)\n", "File \u001b[0;32m/usr/local/lib/python3.8/dist-packages/matplotlib/animation.py:1750\u001b[0m, in \u001b[0;36mFuncAnimation._init_draw\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1748\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_draw_frame(frame_data)\n\u001b[1;32m 1749\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m-> 1750\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_drawn_artists \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_init_func()\n\u001b[1;32m 1751\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_blit:\n\u001b[1;32m 1752\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_drawn_artists \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n", "Cell \u001b[0;32mIn[6], line 9\u001b[0m, in \u001b[0;36minit_hand\u001b[0;34m()\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39minit_hand\u001b[39m():\n\u001b[0;32m----> 9\u001b[0m \u001b[39mreturn\u001b[39;00m plot_hand_keypoints(norm_df, \u001b[39m\"\u001b[39m\u001b[39mright\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39m0\u001b[39m, ret\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m)\n", "\u001b[0;31mNameError\u001b[0m: name 'plot_hand_keypoints' is not defined" ] }, { "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", "ax.set_aspect('equal')\n", "ax.set_title(\"Right Hand\")\n", "ax.set_xlabel(\"x\")\n", "ax.set_ylabel(\"y\")\n", "\n", "def init_hand():\n", " return plot_hand_keypoints(norm_df, \"right\", 0, ret=True)\n", "\n", "def animate_hand(i):\n", " return plot_hand_keypoints(norm_df, \"right\", i, ret=True)\n", "\n", "# show animation of the keypoints over time, show one frame every 1000ms and remove the other frames\n", "anim = animation.FuncAnimation(fig, animate_hand, init_func=init_hand, frames=norm_df.shape[0], interval=1000, repeat=False, )\n", "HTML(anim.to_html5_video())" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "execution_count": 14, "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", "ax = plt.axes(xlim=(-0.5, 0.5), ylim=(-0.5, 0.5))\n", "ax.set_aspect('equal')\n", "ax.set_title(\"Left Hand\")\n", "ax.set_xlabel(\"x\")\n", "ax.set_ylabel(\"y\")\n", "\n", "def init_hand():\n", " return plot_hand_keypoints(norm_df, \"left\", 0, ret=True)\n", "\n", "def animate_hand(i):\n", " return plot_hand_keypoints(norm_df, \"left\", i, ret=True)\n", "\n", "# show animation of the keypoints over time, show one frame every 1000ms and remove the other frames\n", "anim = animation.FuncAnimation(fig, animate_hand, init_func=init_hand, frames=norm_df.shape[0], interval=1000, repeat=False, )\n", "HTML(anim.to_html5_video())" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "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.8.10" }, "vscode": { "interpreter": { "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6" } } }, "nbformat": 4, "nbformat_minor": 2 }