ui function and no playable out

main_noweb.py

@@ -106,7 +106,7 @@ def pose3d(video, kpt_threshold):
                             #return_vis=True,
                             radius = 5,
                             thickness=4,
-                            rebase_keypoint_height=False,
+                            rebase_keypoint_height=True,
                             kpt_thr=kpt_threshold,
                             device=device,
                             pred_out_dir = add_dir
@@ -177,145 +177,147 @@ def pose2dhand(video, kpt_threshold):
    
     return "".join(out_file)
 
-block = gr.Blocks()
-with block:
-    with gr.Column():       
-        with gr.Tab("Upload video"):
-            with gr.Column():
-                with gr.Row():
-                    with gr.Column():
-                        video_input = gr.Video(source="upload", type="filepath", height=512, width=512)
-                        # Insert slider with kpt_thr
-                        file_kpthr = gr.Slider(0, 1, value=0.3, label='Keypoint threshold')
-                        with gr.Row():
-                            submit_pose_file = gr.Button("Make 2d pose estimation")
-                            submit_pose3d_file = gr.Button("Make 3d pose estimation")
-                            submit_hand_file = gr.Button("Make 2d hand estimation")
-                            submit_detect_file = gr.Button("Detect and track objects")
-
-                with gr.Row():
-                    video_output1 = gr.PlayableVideo(height=512,  label = "Estimate human 2d poses", show_label=True)
-                    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
+def UI():
+    block = gr.Blocks()
+    with block:
+        with gr.Column():       
+            with gr.Tab("Upload video"):
+                with gr.Column():
+                    with gr.Row():
+                        with gr.Column():
+                            video_input = gr.Video(source="upload", type="filepath", height=512, width=512)
+                            # Insert slider with kpt_thr
+                            file_kpthr = gr.Slider(0, 1, value=0.3, label='Keypoint threshold')
+                            with gr.Row():
+                                submit_pose_file = gr.Button("Make 2d pose estimation")
+                                submit_pose3d_file = gr.Button("Make 3d pose estimation")
+                                submit_hand_file = gr.Button("Make 2d hand estimation")
+                                submit_detect_file = gr.Button("Detect and track objects")
+
+                    with gr.Row():
+                        video_output1 = gr.PlayableVideo(height=512,  label = "Estimate human 2d poses", show_label=True)
+                        video_output2 = gr.Video(height=512,  label = "Estimate human 3d poses", show_label=True)
+                        video_output3 = gr.PlayableVideo(height=512,  label = "Estimate human hand poses", show_label=True)
                     
-                    kpointlist=[]
+                    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)
+                        # 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
+                        # 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
                             
-                        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
+                            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 
 
-                    # COCO keypoint indices
-                    shoulder_index = 6
-                    elbow_index = 8
-                    wrist_index = 9
+                        # 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
 
-                    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]
+                        # COCO keypoint indices
+                        shoulder_index = 6
+                        elbow_index = 8
+                        wrist_index = 9
 
-                    angle = calculate_angle(shoulder_point, elbow_point, wrist_point)
-                    print("Angle is: ", angle)    
+                        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]
 
-                    """,
-                    language="python",
-                    interactive=False,
-                    show_label=False,
-                )
+                        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"):
-            gr.Markdown(""" 
-                        \n # Information about the models 
 
-                        \n ## Pose models: 
-                        
-                        \n All the pose estimation models come from the library [MMpose](https://github.com/open-mmlab/mmpose). It is a library for human pose estimation that provides pre-trained models for 2D and 3D pose estimation. 
+            with gr.Tab("General information"):
+                gr.Markdown(""" 
+                            \n # Information about the models 
 
-                        \n The 2D pose model is used for estimating the 2D coordinates of human body joints from an image or a video frame. The model uses a convolutional neural network (CNN) to predict the joint locations and their confidence scores. 
-                        
-                        \n The 2D hand model is a specialized version of the 2D pose model that is designed for hand pose estimation. It uses a similar CNN architecture to the 2D pose model but is trained specifically for detecting the joints in the hand. 
-                        
-                        \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 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 ## Pose models: 
+                            
+                            \n All the pose estimation models come from the library [MMpose](https://github.com/open-mmlab/mmpose). It is a library for human pose estimation that provides pre-trained models for 2D and 3D pose estimation. 
 
+                            \n The 2D pose model is used for estimating the 2D coordinates of human body joints from an image or a video frame. The model uses a convolutional neural network (CNN) to predict the joint locations and their confidence scores. 
+                            
+                            \n The 2D hand model is a specialized version of the 2D pose model that is designed for hand pose estimation. It uses a similar CNN architecture to the 2D pose model but is trained specifically for detecting the joints in the hand. 
+                            
+                            \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 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 
+                            ```
+                            """)
+
+                
+
+            # From file
+            submit_pose_file.click(fn=pose2d, 
+                                inputs=  [video_input, file_kpthr], 
+                                outputs = [video_output1, jsonoutput],
+                                queue=True)
             
-
-        # From file
-        submit_pose_file.click(fn=pose2d, 
-                            inputs=  [video_input, file_kpthr], 
-                            outputs = [video_output1, jsonoutput],
-                            queue=True)
-        
-        submit_pose3d_file.click(fn=pose3d, 
+            submit_pose3d_file.click(fn=pose3d, 
+                                    inputs= [video_input, file_kpthr], 
+                                    outputs = video_output2,
+                                    queue=True)
+            
+            submit_hand_file.click(fn=pose2dhand, 
                                 inputs= [video_input, file_kpthr], 
-                                outputs = video_output2,
+                                outputs = video_output3,
                                 queue=True)
-        
-        submit_hand_file.click(fn=pose2dhand, 
-                            inputs= [video_input, file_kpthr], 
-                            outputs = video_output3,
-                            queue=True)
+        return block
         
 if __name__ == "__main__":
+    block = UI()
     block.queue(
                 #concurrency_count=40, # When you increase the concurrency_count parameter in queue(), max_threads() in launch() is automatically increased as well.
                 #max_size=25, # Maximum number of requests that the queue processes
                 api_open = False # When creating a Gradio demo, you may want to restrict all traffic to happen through the user interface as opposed to the programmatic API that is automatically created for your Gradio demo.  
                     ).launch(
-                #enable_queue=True,
                 server_name="0.0.0.0", 
                  server_port=7860,
                  auth=("novouser", "bstad2023")