adding a subscriber for testing

keypoint-db/ws/src/db_loader/db_loader/keypoint_subscriber.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+
+"""
+Example ROS2 subscriber for skeleton keypoints published by keypoint_publisher.py
+
+This script demonstrates how to subscribe to and process the keypoint data.
+The keypoints are published as JSON on the /skeleton_keypoints topic.
+"""
+
+import rclpy
+from rclpy.node import Node
+from std_msgs.msg import String
+import json
+
+
+class KeypointSubscriberExample(Node):
+    def __init__(self):
+        super().__init__('keypoint_subscriber_example')
+        
+        # Subscribe to keypoint data (JSON format)
+        self.keypoints_sub = self.create_subscription(
+            String,
+            'skeleton_keypoints',
+            self.keypoints_callback,
+            10
+        )
+        
+        self.get_logger().info('Keypoint subscriber started')
+        self.get_logger().info('Listening to: /skeleton_keypoints (JSON)')
+    
+    def keypoints_callback(self, msg):
+        """Handle JSON messages containing all keypoint data"""
+        try:
+            data = json.loads(msg.data)
+            
+            person_id = data['person_id']
+            timestamp = data['timestamp']
+            keypoints = data['keypoints']
+            
+            self.get_logger().info(f'\n=== Person {person_id} at t={timestamp:.2f}s ===')
+            self.get_logger().info(f'Total keypoints: {len(keypoints)}')
+            
+            # Example 1: Print all keypoints
+            for kpt in keypoints:
+                name = kpt['name']
+                pos = kpt['position']
+                self.get_logger().info(
+                    f'  {name:20s}: ({pos["x"]:7.3f}, {pos["y"]:7.3f}, {pos["z"]:7.3f})'
+                )
+            
+        except json.JSONDecodeError as e:
+            self.get_logger().error(f'Failed to parse JSON: {e}')
+        except KeyError as e:
+            self.get_logger().error(f'Missing expected field: {e}')
+
+
+class KeypointProcessor(Node):
+    """
+    More advanced example that processes keypoint data to compute useful metrics
+    """
+    def __init__(self):
+        super().__init__('keypoint_processor')
+        
+        self.keypoints_sub = self.create_subscription(
+            String,
+            'skeleton_keypoints',
+            self.process_keypoints,
+            10
+        )
+        
+        self.get_logger().info('Keypoint processor started')
+    
+    def process_keypoints(self, msg):
+        """Process keypoint data to compute useful metrics"""
+        try:
+            data = json.loads(msg.data)
+            
+            # Convert list of keypoints to a dictionary for easier access
+            keypoints = {kpt['name']: kpt['position'] for kpt in data['keypoints']}
+            
+            person_id = data['person_id']
+            
+            # Example 1: Calculate person height (neck to ankle distance)
+            if 'neck' in keypoints and 'right_ankle' in keypoints:
+                neck = keypoints['neck']
+                ankle = keypoints['right_ankle']
+                
+                height = ((neck['x'] - ankle['x'])**2 + 
+                         (neck['y'] - ankle['y'])**2 + 
+                         (neck['z'] - ankle['z'])**2)**0.5
+                
+                self.get_logger().info(
+                    f'Person {person_id} - Height: {height:.2f}m'
+                )
+            
+            # Example 2: Calculate shoulder width
+            if 'right_shoulder' in keypoints and 'left_shoulder' in keypoints:
+                rs = keypoints['right_shoulder']
+                ls = keypoints['left_shoulder']
+                
+                shoulder_width = ((rs['x'] - ls['x'])**2 + 
+                                 (rs['y'] - ls['y'])**2 + 
+                                 (rs['z'] - ls['z'])**2)**0.5
+                
+                self.get_logger().info(
+                    f'Person {person_id} - Shoulder width: {shoulder_width:.2f}m'
+                )
+            
+            # Example 3: Detect raised hands
+            if all(k in keypoints for k in ['neck', 'right_hand', 'left_hand']):
+                neck_z = keypoints['neck']['z']
+                right_hand_z = keypoints['right_hand']['z']
+                left_hand_z = keypoints['left_hand']['z']
+                
+                if right_hand_z > neck_z + 0.2:
+                    self.get_logger().info(f'Person {person_id} - Right hand raised!')
+                if left_hand_z > neck_z + 0.2:
+                    self.get_logger().info(f'Person {person_id} - Left hand raised!')
+            
+        except Exception as e:
+            self.get_logger().error(f'Error processing keypoints: {e}')
+
+
+def main_simple(args=None):
+    """Run the simple keypoint subscriber example"""
+    rclpy.init(args=args)
+    node = KeypointSubscriberExample()
+    
+    try:
+        rclpy.spin(node)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        node.destroy_node()
+        rclpy.shutdown()
+
+
+def main_processor(args=None):
+    """Run the keypoint processor example"""
+    rclpy.init(args=args)
+    node = KeypointProcessor()
+    
+    try:
+        rclpy.spin(node)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        node.destroy_node()
+        rclpy.shutdown()
+
+
+def main(args=None):
+    """Main entry point - runs the simple subscriber by default"""
+    main_simple(args)
+
+
+if __name__ == '__main__':
+    main()