JSON

main_noweb.py

@@ -215,7 +215,60 @@ with block:
                     video_output2 = gr.PlayableVideo(height=512,  label = "Estimate human 3d poses", show_label=True)
                     video_output3 = gr.PlayableVideo(height=512,  label = "Estimate human hand poses", show_label=True)
                     video_output4 = gr.Video(height=512, label = "Detection and tracking", show_label=True, format="mp4")
+                gr.Markdown("Download the .json file that contains the keypoint positions for each frame in the video.")
                 jsonoutput = gr.File(file_types=[".json"])
+                gr.Markdown("""There are multiple ways to interact with these keypoints. 
+                            \n The example below shows how you can calulate the angle on the elbow for example.
+                            \n Copy the code into your own preferred interpreter and experiment with the keypoint file. 
+                            \n If you choose to run the code, start by installing the packages json and numpy. The complete overview of the keypoint indices can be seen in the tab 'General information'. """)
+                gr.Code(
+                    value="""
+                            # Importing packages needed  
+                            import json
+                            import numpy as np
+                            
+                            kpointlist=[]
+
+                            # First we load the data
+                            with open(file_path, 'r') as json_file:
+                                data = json.load(json_file)
+
+                            # The we define a function for calculating angles    
+                            def calculate_angle(a, b, c):
+                                a = np.array(a) # First point
+                                b = np.array(b) # Middle point
+                                c = np.array(c) # End point
+                                
+                                radians = np.arctan2(c[1]-b[1], c[0]-b[0]) - np.arctan2(a[1]-b[1], a[0]-b[0])
+                                angle = np.abs(radians*180.0/np.pi)
+                                
+                                if angle >180.0:
+                                    angle = 360-angle
+                                    
+                                return angle 
+
+                            # We select the first identified person in the first frame (zero index) as an example
+                            # To calculate the angle of the right elbow we take the point before and after and according to the indices that will be 6 (right shoulder) and 9 (right wrist)
+                            predictions = data['predictions'][0]  # Assuming batch_size is 1
+
+                            # COCO keypoint indices
+                            shoulder_index = 6
+                            elbow_index = 8
+                            wrist_index = 9
+
+                            shoulder_point = data[0]['instances'][0]['keypoints'][shoulder_index]
+                            elbow_point = data[0]['instances'][0]['keypoints'][elbow_index]
+                            wrist_point = data[0]['instances'][0]['keypoints'][wrist_index]
+
+                            angle = calculate_angle(shoulder_point, elbow_point, wrist_point)
+                            print("Angle is: ", angle)    
+
+                          """,
+                    language="python",
+                    interactive=False,
+                    show_label=False,
+                )
+
 
 
         with gr.Tab("General information"):
@@ -232,23 +285,30 @@ with block:
                         
                         \n The 3D pose model is used for estimating the 3D coordinates of human body joints from an image or a video frame. The model uses a combination of 2D pose estimation and depth estimation to infer the 3D joint locations. 
                         
-                        \n 
+                        \n The keypoints in the 2D pose model has the following order:
+
+                        \n ``` 0: Nose
+                               1: Left Eye
+                               2: Right Eye
+                               3: Left Ear
+                               4: Right Ear
+                               5: Left Shoulder
+                               6: Right Shoulder
+                               7: Left Elbow
+                               8: Right Elbow
+                               9: Left Wrist
+                               10: Right Wrist
+                               11: Left Hip
+                               12: Right Hip
+                               13: Left Knee
+                               14: Right Knee
+                               15: Left Ankle
+                               16: Right Ankle ```
 
-                        \n ## Detection and tracking:                            
-                        
-                        \n The tracking method in the Ultralight's YOLOv8 model is used for object tracking in videos. It takes a video file or a camera stream as input and returns the tracked objects in each frame. The method uses the COCO dataset classes for object detection and tracking. 
                         
-                        \n The COCO dataset contains 80 classes of objects such as person, car, bicycle, etc. See https://docs.ultralytics.com/datasets/detect/coco/ for all available classes. The tracking method uses the COCO classes to detect and track the objects in the video frames. The tracked objects are represented as bounding boxes with labels indicating the class of the object.""")
+                        """)
             gr.Markdown("You can load the keypoints in python in the following way: ")
-            gr.Code(
-                    value="""def hello_world():
-                                    return "Hello, world!"
-                
-                            print(hello_world())""",
-                    language="python",
-                    interactive=False,
-                    show_label=False,
-                )
+
             
 
         # From file