publish keypoints, not only visual markers

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

@@ -4,6 +4,8 @@ import rclpy
 from rclpy.node import Node
 from visualization_msgs.msg import Marker, MarkerArray
 from geometry_msgs.msg import Point
+from std_msgs.msg import String
+import json
 import pandas as pd
 import numpy as np
 import argparse
@@ -21,6 +23,14 @@ class KeypointPublisher(Node):
             100
         )
         
+        # Publisher for keypoint data (JSON format via String message)
+        # Contains person_id, timestamp, and all keypoints with names and positions
+        self.keypoints_pub = self.create_publisher(
+            String,
+            'skeleton_keypoints',
+            100
+        )
+        
         self.playback_speed = playback_speed
         self.interpolate = interpolate
         self.previous_persons = set()
@@ -110,7 +120,8 @@ class KeypointPublisher(Node):
             self.update_rate = publish_rate
             self.timer = self.create_timer(1.0 / self.update_rate, self.publish_callback)
             self.get_logger().info(f'Starting playback at {playback_speed}x speed')
-            self.get_logger().info(f'Publishing markers at {publish_rate} Hz')
+            self.get_logger().info(f'Publishing at {publish_rate} Hz')
+            self.get_logger().info(f'Topics: /skeleton_markers (visualization), /skeleton_keypoints (JSON data)')
             self.get_logger().info(f'Interpolation: {"ENABLED" if self.interpolate else "DISABLED"}')
     
     def _generate_color(self):
@@ -316,6 +327,37 @@ class KeypointPublisher(Node):
         
         return markers
     
+    def _publish_keypoints_for_person(self, person_id, frame, publish_timestamp):
+        """Publish keypoint positions and metadata for a single person as JSON"""
+        # Create metadata dictionary with all keypoint information
+        metadata = {
+            'person_id': str(person_id),
+            'timestamp': publish_timestamp,
+            'keypoints': []
+        }
+        
+        # Extract all keypoint positions with their names
+        for keypoint_name in self.keypoint_names:
+            pos = self._get_keypoint_position(frame, keypoint_name)
+            
+            if pos is not None:
+                metadata['keypoints'].append({
+                    'name': keypoint_name,
+                    'position': {
+                        'x': float(pos[0]),
+                        'y': float(pos[1]),
+                        'z': float(pos[2])
+                    }
+                })
+        
+        # Publish as JSON string (only if we have at least one keypoint)
+        if metadata['keypoints']:
+            msg = String()
+            msg.data = json.dumps(metadata)
+            self.keypoints_pub.publish(msg)
+
+
+    
     def _init_multi_chunk_mode(self, index_file_path):
         """Initialize multi-chunk playback mode from index file"""
         try:
@@ -538,6 +580,13 @@ class KeypointPublisher(Node):
                         publish_timestamp
                     )
                     marker_array.markers.extend(person_markers)
+                    
+                    # Publish keypoint data for this person
+                    self._publish_keypoints_for_person(
+                        person_id_str,
+                        frame,
+                        publish_timestamp
+                    )
             
             mode_str = "interpolated" if self.interpolate else "nearest"
             self.get_logger().debug(f'Created {mode_str} markers for {len(unique_persons)} persons at t={publish_timestamp:.2f}s')

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

@@ -35,6 +35,7 @@ setup(
             'layout_visualizer = db_loader.layout_visualizer:main',
             'keypoint_publisher = db_loader.keypoint_publisher:main',
             'index_keypoint_publisher = db_loader.index_keypoint_publisher:main',
+            'keypoint_subscriber = db_loader.keypoint_subscriber:main',
         ],
     },
 )