vérifié ok

blender-skeleton/scripts/always.py

@@ -180,6 +180,7 @@ def main():
         gl.t = time()
         # #print(int(gl.fps/10))
         gl.fps = 0
+        print("Body n°:", gl.body)
 
     keyboard()
 

blender-skeleton/scripts/once.py

@@ -16,8 +16,9 @@ def default_handler(*args):
 
 
 def on_points(*args):
+    # Je récupère le body
+    gl.body = args[-1]
     # J'ôte le body
-    body = args[-1]
     args = args[:-1]
 
     gl.points = get_points(args)
@@ -87,7 +88,7 @@ def main():
     gl.body_visible = 1
     gl.person.visible = 0
 
-    gl.debug = 1  # 1=avec fichier enregistré
+    gl.debug = 0  # 1=avec fichier enregistré
     if gl.debug:
         b = './scripts/json/cap_2021_04_17_13_56.json'
         gl.data = read_json(b)

doc/skeleton-tracking-realsense.py

@@ -0,0 +1,143 @@
+
+from collections import namedtuple
+import util as cm
+import cv2
+import time
+import pyrealsense2 as rs
+import math
+import numpy as np
+from skeletontracker import skeletontracker
+
+
+def render_ids_3d(
+    render_image, skeletons_2d, depth_map, depth_intrinsic, joint_confidence
+):
+    thickness = 1
+    text_color = (255, 255, 255)
+    rows, cols, channel = render_image.shape[:3]
+    distance_kernel_size = 5
+    # calculate 3D keypoints and display them
+    for skeleton_index in range(len(skeletons_2d)):
+        skeleton_2D = skeletons_2d[skeleton_index]
+        joints_2D = skeleton_2D.joints
+        did_once = False
+        for joint_index in range(len(joints_2D)):
+            if did_once == False:
+                cv2.putText(
+                    render_image,
+                    "id: " + str(skeleton_2D.id),
+                    (int(joints_2D[joint_index].x), int(joints_2D[joint_index].y - 30)),
+                    cv2.FONT_HERSHEY_SIMPLEX,
+                    0.55,
+                    text_color,
+                    thickness,
+                )
+                did_once = True
+            # check if the joint was detected and has valid coordinate
+            if skeleton_2D.confidences[joint_index] > joint_confidence:
+                distance_in_kernel = []
+                low_bound_x = max(
+                    0,
+                    int(
+                        joints_2D[joint_index].x - math.floor(distance_kernel_size / 2)
+                    ),
+                )
+                upper_bound_x = min(
+                    cols - 1,
+                    int(joints_2D[joint_index].x + math.ceil(distance_kernel_size / 2)),
+                )
+                low_bound_y = max(
+                    0,
+                    int(
+                        joints_2D[joint_index].y - math.floor(distance_kernel_size / 2)
+                    ),
+                )
+                upper_bound_y = min(
+                    rows - 1,
+                    int(joints_2D[joint_index].y + math.ceil(distance_kernel_size / 2)),
+                )
+                for x in range(low_bound_x, upper_bound_x):
+                    for y in range(low_bound_y, upper_bound_y):
+                        distance_in_kernel.append(depth_map.get_distance(x, y))
+                median_distance = np.percentile(np.array(distance_in_kernel), 50)
+                depth_pixel = [
+                    int(joints_2D[joint_index].x),
+                    int(joints_2D[joint_index].y),
+                ]
+                if median_distance >= 0.3:
+                    point_3d = rs.rs2_deproject_pixel_to_point(
+                        depth_intrinsic, depth_pixel, median_distance
+                    )
+                    point_3d = np.round([float(i) for i in point_3d], 3)
+                    point_str = [str(x) for x in point_3d]
+                    cv2.putText(
+                        render_image,
+                        str(point_3d),
+                        (int(joints_2D[joint_index].x), int(joints_2D[joint_index].y)),
+                        cv2.FONT_HERSHEY_DUPLEX,
+                        0.4,
+                        text_color,
+                        thickness,
+                    )
+
+
+# Main content begins
+if __name__ == "__main__":
+    try:
+        # Configure depth and color streams of the intel realsense
+        config = rs.config()
+        config.enable_stream(rs.stream.depth, 1280, 720, rs.format.z16, 30)
+        config.enable_stream(rs.stream.color, 1280, 720, rs.format.bgr8, 30)
+
+        # Start the realsense pipeline
+        pipeline = rs.pipeline()
+        pipeline.start()
+
+        # Create align object to align depth frames to color frames
+        align = rs.align(rs.stream.color)
+
+        # Get the intrinsics information for calculation of 3D point
+        unaligned_frames = pipeline.wait_for_frames()
+        frames = align.process(unaligned_frames)
+        depth = frames.get_depth_frame()
+        depth_intrinsic = depth.profile.as_video_stream_profile().intrinsics
+
+        # Initialize the cubemos api with a valid license key in default_license_dir()
+        skeletrack = skeletontracker(cloud_tracking_api_key="")
+        joint_confidence = 0.2
+
+        # Create window for initialisation
+        window_name = "cubemos skeleton tracking with realsense D400 series"
+        cv2.namedWindow(window_name, cv2.WINDOW_NORMAL + cv2.WINDOW_KEEPRATIO)
+
+        while True:
+            # Create a pipeline object. This object configures the streaming camera and owns it's handle
+            unaligned_frames = pipeline.wait_for_frames()
+            frames = align.process(unaligned_frames)
+            depth = frames.get_depth_frame()
+            color = frames.get_color_frame()
+            if not depth or not color:
+                continue
+
+            # Convert images to numpy arrays
+            depth_image = np.asanyarray(depth.get_data())
+            color_image = np.asanyarray(color.get_data())
+
+            # perform inference and update the tracking id
+            skeletons = skeletrack.track_skeletons(color_image)
+
+            # render the skeletons on top of the acquired image and display it
+            color_image = cv2.cvtColor(color_image, cv2.COLOR_BGR2RGB)
+            cm.render_result(skeletons, color_image, joint_confidence)
+            render_ids_3d(
+                color_image, skeletons, depth, depth_intrinsic, joint_confidence
+            )
+            cv2.imshow(window_name, color_image)
+            if cv2.waitKey(1) == 27:
+                break
+
+        pipeline.stop()
+        cv2.destroyAllWindows()
+
+    except Exception as ex:
+        print('Exception occured: "{}"'.format(ex))

get_skeleton/get_cubemos_skeleton.ini

@@ -1,5 +1,5 @@
 [cubemos]
 gestures = 1
-ip = '192.168.1.101'
+ip = b'localhost'
 port = 8003
 save = 1

get_skeleton/get_cubemos_skeleton.py

@@ -10,8 +10,9 @@
 from osc_client import OscClt
 
 import pyrealsense2 as rs
+
+# Script particulier de cubemos dans le dossier de ce projet avec la clé !!
 from skeletontracker import skeletontracker
-# Script particulier de cubemos dans le dossier  avec la clé !!
 import util as cm
 
 
@@ -30,11 +31,11 @@ def __init__(self, **kwargs):
         if self.gest:
             self.gestures = Gestures(self.clt)
 
-    def render_ids_3d(self, render_image, skeletons_2d, depth_map,
-                        depth_intrinsic, joint_confidence):
+    def render_ids_3d(self, color_image, skeletons_2d, depth_map,
+                            depth_intrinsic, joint_confidence):
+        """Calcul les coordonnées 3D des squelettes."""
 
-        thickness = 1
-        rows, cols, channel = render_image.shape[:3]
+        rows, cols, channel = color_image.shape[:3]
         # kernel = distance_kernel_size
         kernel = 5
         joints_2D = 0
@@ -45,7 +46,7 @@ def render_ids_3d(self, render_image, skeletons_2d, depth_map,
         for skeleton_index in range(len(skeletons_2d)):
             skeleton_2D = skeletons_2d[skeleton_index]
             joints_2D = skeleton_2D.joints
-            did_once = False
+            skeleton_id = skeleton_2D.id
 
             for joint_index in range(len(joints_2D)):
                 # check if the joint was detected and has valid coordinate
@@ -73,10 +74,9 @@ def render_ids_3d(self, render_image, skeletons_2d, depth_map,
                                                                    median_distance)
                         points_3D[joint_index] = point_3d
 
-        self.clt.send_global_message(points_3D)
-        self.gestures.add_points(points_3D)
+            self.clt.send_global_message(points_3D, skeleton_id)
+            self.gestures.add_points(points_3D)
 
-        return joints_2D, point_3d
 
     def run(self):
         # Configure depth and color streams of the intel realsense
@@ -147,7 +147,7 @@ def run(self):
 if __name__ == "__main__":
 
     # Chargement de la configuration
-    ini_file = '/media/data/3D/projets/cubemos-skeleton/get_skeleton/get_cubemos_skeleton.ini'
+    ini_file = 'get_cubemos_skeleton.ini'
     my_config = MyConfig(ini_file)
 
     kwargs = my_config.conf['cubemos']

get_skeleton/osc_client.py

@@ -4,8 +4,14 @@
 from oscpy.client import OSCClient
 
 class OscClt:
-    def __init__(self, ip, port):
+    """Un client OSC spécifique pour envoyer les points Cubemos,
+    et enregistrer ces points dans un fichier pour debug.
+    """
 
+    def __init__(self, ip, port):
+        """ ip = "192.168.1.101"
+            ip = b'localhost'
+        """
         self.ip = ip
         self.port = port
         # Pour l'enregistrement d'un json à la fin de la capture
@@ -40,6 +46,7 @@ def send_msg(self, adress, note):
 
     def save(self):
         """Enregistrement des messages envoyés pour debug de la réception"""
+
         dt_now = datetime.now()
         dt = dt_now.strftime("%Y_%m_%d_%H_%M")
         fichier = f"json/cap_{dt}.json"  # dans le home