High Resolution Pose Estimation new tool

projects/python/perception/high_resolution_pose_estimation/README.md

@@ -0,0 +1,11 @@
+# High Resolution Pose Estimation
+
+This folder contains sample applications  that demonstrate various parts of the functionality provided by the High Resolution Pose Estimation algorithm provided by OpenDR.
+
+More specific, the applications provided are:
+
+1. demos/inference_demo.py: A tool that demonstrates how to perform inference on a single high resolution image and then draw the detected poses. 
+2. demos/eval_demo.py: A tool that demonstrates how to perform evaluation using the High Resolution Pose Estimation algorithm on a 720p, 1080p, 1440p dataset. 
+3. demos/benchmarking.py: A simple benchmarking tool for measuring the performance of High Resolution Pose Estimation in various platforms.
+
+

projects/python/perception/high_resolution_pose_estimation/demos/benchmarking_demo.py

@@ -0,0 +1,87 @@
+# Copyright 2020-2022 OpenDR European Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import cv2
+import time
+from opendr.perception.pose_estimation import HighResolutionPoseEstimationLearner
+import argparse
+from os.path import join
+from tqdm import tqdm
+import numpy as np
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--onnx", help="Use ONNX", default=False, action="store_true")
+    parser.add_argument("--device", help="Device to use (cpu, cuda)", type=str, default="cuda")
+    parser.add_argument("--accelerate", help="Enables acceleration flags (e.g., stride)", default=False,
+                        action="store_true")
+    parser.add_argument("--height1", help="Base height of resizing in heatmap generation", default=360)
+    parser.add_argument("--height2", help="Base height of resizing in second inference", default=540)
+
+    args = parser.parse_args()
+
+    onnx, device, accelerate, base_height1, base_height2 = args.onnx, args.device, args.accelerate,\
+        args.height1, args.height2
+
+    if device == 'cpu':
+        import torch
+        torch.set_flush_denormal(True)
+        torch.set_num_threads(8)
+
+    if accelerate:
+        stride = True
+        stages = 0
+        half_precision = True
+    else:
+        stride = False
+        stages = 2
+        half_precision = False
+
+    pose_estimator = HighResolutionPoseEstimationLearner(device=device, num_refinement_stages=stages,
+                                                         mobilenet_use_stride=stride, half_precision=half_precision,
+                                                         first_pass_height=base_height1,
+                                                         second_pass_height=base_height2)
+    pose_estimator.download(path=".", verbose=True)
+    pose_estimator.load("openpose_default")
+
+    # Download one sample image
+    pose_estimator.download(path=".", mode="test_data")
+    image_path = join("temp", "dataset", "image", "000000000785_1080.jpg")
+    img = cv2.imread(image_path)
+
+    if onnx:
+        pose_estimator.optimize()
+
+    fps_list = []
+    print("Benchmarking...")
+    for i in tqdm(range(50)):
+        start_time = time.perf_counter()
+        # Perform inference
+
+        poses = pose_estimator.infer(img)
+
+        end_time = time.perf_counter()
+        fps_list.append(1.0 / (end_time - start_time))
+    print("Average FPS: %.2f" % (np.mean(fps_list)))
+
+    # If pynvml is available, try to get memory stats for cuda
+    try:
+        if 'cuda' in device:
+            from pynvml import nvmlInit, nvmlDeviceGetMemoryInfo, nvmlDeviceGetHandleByIndex
+
+            nvmlInit()
+            info = nvmlDeviceGetMemoryInfo(nvmlDeviceGetHandleByIndex(0))
+            print("Memory allocated: %.2f MB " % (info.used / 1024 ** 2))
+    except ImportError:
+        pass

projects/python/perception/high_resolution_pose_estimation/demos/eval_demo.py

@@ -0,0 +1,65 @@
+
+# Copyright 2020-2022 OpenDR European Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from opendr.perception.pose_estimation import HighResolutionPoseEstimationLearner
+import argparse
+from os.path import join
+from opendr.engine.datasets import ExternalDataset
+import time
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--onnx", help="Use ONNX", default=False, action="store_true")
+    parser.add_argument("--device", help="Device to use (cpu, cuda)", type=str, default="cuda")
+    parser.add_argument("--accelerate", help="Enables acceleration flags (e.g., stride)", default=False,
+                        action="store_true")
+    parser.add_argument("--height1", help="Base height of resizing in first inference", default=360)
+    parser.add_argument("--height2", help="Base height of resizing in second inference", default=540)
+
+    args = parser.parse_args()
+
+    onnx, device, accelerate, base_height1, base_height2 = args.onnx, args.device, args.accelerate,\
+        args.height1, args.height2
+
+    if accelerate:
+        stride = True
+        stages = 0
+        half_precision = True
+    else:
+        stride = True
+        stages = 2
+        half_precision = True
+
+    pose_estimator = HighResolutionPoseEstimationLearner(device=device, num_refinement_stages=stages,
+                                                         mobilenet_use_stride=stride,
+                                                         half_precision=half_precision,
+                                                         first_pass_height=base_height1,
+                                                         second_pass_height=base_height2)
+    pose_estimator.download(path=".", verbose=True)
+    pose_estimator.load("openpose_default")
+
+    if onnx:
+        pose_estimator.optimize()
+
+    # Download a sample dataset
+    pose_estimator.download(path=".", mode="test_data")
+
+    eval_dataset = ExternalDataset(path=join("temp", "dataset"), dataset_type="COCO")
+
+    t0 = time.time()
+    results_dict = pose_estimator.eval(eval_dataset, use_subset=False, verbose=True, silent=True,
+                                       images_folder_name="image", annotations_filename="annotation.json")
+    t1 = time.time()
+    print("\n Evaluation time:  ", t1 - t0, "seconds")
+    print("Evaluation results = ", results_dict)

projects/python/perception/high_resolution_pose_estimation/demos/inference_demo.py

@@ -0,0 +1,71 @@
+
+# Copyright 2020-2022 OpenDR European Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import cv2
+from opendr.perception.pose_estimation import HighResolutionPoseEstimationLearner
+
+from opendr.perception.pose_estimation import draw
+from opendr.engine.data import Image
+import argparse
+from os.path import join
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--onnx", help="Use ONNX", default=False, action="store_true")
+    parser.add_argument("--device", help="Device to use (cpu, cuda)", type=str, default="cuda")
+    parser.add_argument("--accelerate", help="Enables acceleration flags (e.g., stride)", default=False,
+                        action="store_true")
+    parser.add_argument("--height1", help="Base height of resizing in first inference", default=360)
+    parser.add_argument("--height2", help="Base height of resizing in second inference", default=540)
+
+    args = parser.parse_args()
+
+    onnx, device, accelerate, base_height1, base_height2 = args.onnx, args.device, args.accelerate,\
+        args.height1, args.height2
+
+    if accelerate:
+        stride = True
+        stages = 0
+        half_precision = True
+    else:
+        stride = False
+        stages = 2
+        half_precision = False
+
+    pose_estimator = HighResolutionPoseEstimationLearner(device=device, num_refinement_stages=stages,
+                                                         mobilenet_use_stride=stride, half_precision=half_precision,
+                                                         first_pass_height=base_height1,
+                                                         second_pass_height=base_height2)
+    pose_estimator.download(path=".", verbose=True)
+    pose_estimator.load("openpose_default")
+
+    # Download one sample image
+    pose_estimator.download(path=".", mode="test_data")
+
+    image_path = join("temp", "dataset", "image", "000000000785_1080.jpg")
+
+    img = Image.open(image_path)
+
+    if onnx:
+        pose_estimator.optimize()
+
+    poses = pose_estimator.infer(img)
+
+    img_cv = img.opencv()
+    for pose in poses:
+        draw(img_cv, pose)
+    cv2.imshow('Results', img_cv)
+    cv2.waitKey(0)

src/opendr/perception/pose_estimation/__init__.py

@@ -1,6 +1,8 @@
 from opendr.perception.pose_estimation.lightweight_open_pose.lightweight_open_pose_learner import \
     LightweightOpenPoseLearner
+from opendr.perception.pose_estimation.hr_pose_estimation.HighResolutionLearner import \
+    HighResolutionPoseEstimationLearner
 
 from opendr.perception.pose_estimation.lightweight_open_pose.utilities import draw, get_bbox
 
-__all__ = ['LightweightOpenPoseLearner', 'draw', 'get_bbox']
+__all__ = ['LightweightOpenPoseLearner', 'draw', 'get_bbox', 'HighResolutionPoseEstimationLearner']