adding the ROS2 container and the playing and visualization scripts

keypoint-db/.env

@@ -0,0 +1 @@
+IMAGE_TAG=humble

keypoint-db/Dockerfile

@@ -0,0 +1,57 @@
+ARG ROS2_DISTRO
+FROM ros:${ROS2_DISTRO}-ros-core
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+ARG APT_MIRROR="us"
+RUN sed --in-place --regexp-extended "s|(//)(archive\.ubuntu)|\1${APT_MIRROR}.\2|" /etc/apt/sources.list
+
+RUN apt-get update \
+  && apt-get install -y --no-install-recommends \
+    bash-completion \
+    build-essential \
+    locate \
+    nano \
+    emacs \
+    python3-colcon-common-extensions \
+    python3-pip \
+    python3-rosdep \
+    sudo \
+  && python3 -m pip install pydocstyle==6.1.1 \
+  && python3 -m pip install pandas \
+  && rosdep init \
+  && apt-get install -y --no-install-recommends \
+    libeigen3-dev \
+    libpcl-dev \
+    libyaml-cpp-dev \
+    ros-${ROS_DISTRO}-diagnostic-updater \
+    ros-${ROS_DISTRO}-nav2-amcl \
+    ros-${ROS_DISTRO}-nav2-lifecycle-manager \
+    ros-${ROS_DISTRO}-nav2-map-server \
+    ros-${ROS_DISTRO}-nav2-rviz-plugins \
+    ros-${ROS_DISTRO}-pcl-conversions \
+    ros-${ROS_DISTRO}-pcl-msgs \
+    ros-${ROS_DISTRO}-rqt-image-view \
+    ros-${ROS_DISTRO}-rqt-graph \
+    ros-${ROS_DISTRO}-rviz2 \
+    ros-${ROS_DISTRO}-tf2 \
+    ros-${ROS_DISTRO}-tf2-geometry-msgs \
+    ros-${ROS_DISTRO}-tf2-sensor-msgs \
+    ros-${ROS_DISTRO}-tf2-eigen \
+    ros-${ROS_DISTRO}-v4l2-camera \
+    ros-${ROS_DISTRO}-pcl-ros \
+
+  && rm -rf /var/lib/apt/lists/*
+
+ARG USER_ID
+ARG GROUP_ID
+RUN addgroup --gid ${GROUP_ID} user \
+  && adduser --disabled-password --gecos '' --uid ${USER_ID} --gid ${GROUP_ID} user \
+  && usermod -a -G sudo,video user \
+  && echo '%sudo ALL=(ALL) NOPASSWD:ALL' >> /etc/sudoers
+
+USER user
+RUN echo "source /opt/ros/${ROS_DISTRO}/setup.bash" >> /home/user/.bashrc \
+  && echo "source /home/user/ws/install/setup.bash" >> /home/user/.bashrc
+
+WORKDIR /home/user/ws

keypoint-db/Makefile

@@ -0,0 +1,16 @@
+ROS2_DISTRO         ?= $(shell cat .env | grep IMAGE_TAG | cut -d = -f 2)
+IMAGE_NAME          := ros2_devel
+IMAGE_TAG           = $(ROS2_DISTRO)
+APT_MIRROR          ?= jp
+USER_ID             :=$(shell id -u)
+GROUP_ID            :=$(shell id -g)
+DOCKER_BUILD_OPTS   ?=
+
+.PHONY: build-image
+build-image:
+	docker build $(DOCKER_BUILD_OPTS) \
+		-t $(IMAGE_NAME):$(IMAGE_TAG) \
+		--build-arg ROS2_DISTRO=$(ROS2_DISTRO) \
+		--build-arg APT_MIRROR=$(APT_MIRROR) \
+		--build-arg USER_ID=$(USER_ID) \
+		--build-arg GROUP_ID=$(GROUP_ID) .

keypoint-db/README.md

@@ -0,0 +1,181 @@
+# ROS2 Docker Container Environment
+
+A containerized ROS2 development environment with GUI support and NVIDIA GPU acceleration. This Docker setup provides an isolated workspace for ROS2 development while maintaining seamless integration with your host filesystem.
+
+## Features
+
+- **ROS2 Distribution**: Default `humble` (configurable)
+- **GUI Support**: X11 forwarding for ROS2 GUI applications
+- **GPU Support**: NVIDIA GPU acceleration (when available)
+- **Workspace Mounting**: Host `ws/` directory mounted with full permissions
+- **User Permissions**: Runs with matching host user/group IDs
+- **Sample Movie**: [video](https://youtu.be/2pLzEvx31iA)
+
+## Prerequisites
+
+- **Docker**: Install following [Docker Engine installation guide](https://docs.docker.com/engine/install)
+- **Post-install Setup**: Configure Docker for [non-root usage](https://docs.docker.com/engine/install/linux-postinstall)
+- **NVIDIA Runtime** (optional): For GPU support, install [nvidia-container-toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html)
+
+## Quick Start
+
+1. **Clone and navigate to repository**
+   ```bash
+   git clone git@github.com:Standard-Cognition/keypoint-db.git
+   cd keypoint_db
+   ```
+
+2. **Build the container**
+   ```bash
+   make
+   ```
+
+3. **Create workspace**
+   ```bash
+   mkdir -p ./ws/src
+   # Copy your ROS2 packages to ws/src/
+   ```
+
+4. **Run container**
+   ```bash
+   ./run_container.sh
+   ```
+
+5. **Join from another terminal** (optional)
+   ```bash
+   ./join_container.sh
+   ```
+
+## Detailed Usage
+
+### Building the Container
+
+**Basic build:**
+```bash
+make
+```
+
+**Custom ROS2 distribution:**
+```bash
+ROS2_DISTRO=humble DOCKER_BUILD_OPTS="--no-cache" make
+```
+
+**Additional build options:**
+```bash
+DOCKER_BUILD_OPTS="--pull=true --no-cache" make
+```
+
+### Container Management
+
+**Start main container:**
+```bash
+./run_container.sh
+```
+
+**Start with specific ROS2 distribution:**
+```bash
+./run_container.sh --distro humble
+```
+
+**Join running container from another terminal:**
+```bash
+./join_container.sh
+```
+
+**Alternative docker-compose method:**
+```bash
+docker compose run --rm --name ros2_devel_container ros2_dev_env bash
+```
+
+### ROS2 Development Workflow
+
+Inside the container (`/home/user/ws`):
+
+**Install dependencies (first time only):**
+```bash
+sudo apt-get update
+rosdep update
+rosdep install -i --from-path src --rosdistro ${ROS_DISTRO} -y
+```
+
+**Build workspace:**
+```bash
+colcon build
+```
+
+**Source workspace:**
+```bash
+source install/setup.bash
+```
+
+**Run tests:**
+```bash
+colcon test
+colcon test-result --all
+```
+
+## Project Structure
+
+```
+dataset_ros2_container/
+├── Dockerfile              # Container image definition
+├── Makefile                # Build automation
+├── docker-compose.yml      # Docker Compose configuration
+├── .env                    # Environment variables
+├── utils                   # Shared shell utilities
+├── run_container.sh        # Start container script
+├── join_container.sh       # Join running container script
+├── ws/                     # ROS2 workspace (mounted)
+│   ├── src/               # Your ROS2 packages
+│   ├── build/             # Build artifacts
+│   ├── install/           # Installation directory
+│   └── log/               # Build logs
+└── README.md              # This file
+```
+
+## Configuration
+
+### Environment Variables
+
+- `ROS2_DISTRO`: ROS2 distribution (default: from `.env` file)
+- `IMAGE_NAME`: Docker image name (default: `ros2_devel`)
+- `APT_MIRROR`: APT mirror location (default: `jp`)
+- `DOCKER_BUILD_OPTS`: Additional Docker build options
+
+### Container Features
+
+- **X11 Forwarding**: Automatic GUI application support
+- **NVIDIA GPU**: Auto-detected and enabled when available
+- **Network**: Host networking for ROS2 communication
+- **Workspace Persistence**: `ws/` directory changes persist on host
+
+## Troubleshooting
+
+**GPU not detected:**
+- Ensure NVIDIA drivers are installed on host
+- Install nvidia-container-toolkit
+- Verify with `nvidia-smi` command
+
+**Permission issues:**
+- Container runs with host user/group IDs automatically
+- Ensure Docker post-install steps completed
+
+**GUI applications not working:**
+- Verify X11 forwarding: `echo $DISPLAY`
+- Check XAUTH permissions in container
+
+**Build failures:**
+- Use `--no-cache` build option
+- Update base images with `--pull=true`
+
+## Contributing
+
+1. Fork the repository
+2. Create feature branch: `git checkout -b feature-name`
+3. Commit changes: `git commit -am 'Add feature'`
+4. Push branch: `git push origin feature-name`
+5. Submit pull request
+
+## License
+
+See [LICENSE](LICENSE) file for details.

keypoint-db/docker-compose.yml

@@ -0,0 +1,23 @@
+version: '3.5'
+services:
+  ros2_dev_env:
+    image: ros2_devel:${IMAGE_TAG}
+    network_mode: host
+    environment:
+      - NVIDIA_VISIBLE_DEVICES=all
+      - NVIDIA_DRIVER_CAPABILITIES=all
+      - DISPLAY
+      # force libGL to use the NVIDIA GPU
+      - __NV_PRIME_RENDER_OFFLOAD=1
+      - __GLX_VENDOR_LIBRARY_NAME=nvidia
+    volumes:
+      - /tmp/.X11-unix:/tmp/.X11-unix:rw
+      - ./ws:/home/user/ws
+    tty: true
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: 1
+              capabilities: [gpu]

keypoint-db/join_container.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+
+source utils
+
+exec docker exec -it ${CONTAINER_NAME} bash

keypoint-db/run_container.sh

@@ -0,0 +1,51 @@
+#!/usr/bin/env bash
+
+source utils
+
+IMAGE_TAG=$(cat .env | grep IMAGE_TAG | cut -d = -f 2)
+
+while [[ ${#} -gt 0 ]]; do
+  key="${1}"
+
+  case ${key} in
+    -d|--distro)
+      IMAGE_TAG="${2}"
+      shift
+      shift
+      ;;
+    *)
+      echo -e "\e[33mIgnoring unknown option ${key}.\e[0m"
+      exit 1
+      ;;
+  esac
+done
+
+XSOCK=/tmp/.X11-unix
+XAUTH=/tmp/.docker.xauth
+touch ${XAUTH}
+xauth nlist ${DISPLAY} | sed -e 's/^..../ffff/' | xauth -f ${XAUTH} nmerge -
+
+DOCKER_ARGS_GUI="-e DISPLAY "
+DOCKER_ARGS_GUI+="-e XAUTHORITY=${XAUTH} "
+DOCKER_ARGS_GUI+="-v ${XAUTH}:${XAUTH}:rw "
+DOCKER_ARGS_GUI+="-v ${XSOCK}:${XSOCK}:rw "
+
+if command -v nvidia-smi &> /dev/null; then
+  gpu_list=$(nvidia-smi -L)
+  if [[ ! -z ${gpu_list} ]]; then
+    DOCKER_ARGS_GUI+="-e NVIDIA_DRIVER_CAPABILITIES=all "
+    DOCKER_ARGS_GUI+="--gpus=all "
+  else
+    echo -e "\e[33m[WARN]: Cannot find any GPU.\e[0m"
+  fi
+fi
+
+echo "Starting container using ${IMAGE_NAME}:${IMAGE_TAG}"
+
+exec docker run -it --rm --name=${CONTAINER_NAME} \
+  --net=host \
+  --device=/dev/video0 \
+  ${DOCKER_ARGS_GUI} \
+  -v $(pwd)/ws:/home/user/ws \
+  ${IMAGE_NAME}:${IMAGE_TAG} \
+  bash

keypoint-db/utils

@@ -0,0 +1,2 @@
+IMAGE_NAME=$(cat Makefile | grep IMAGE_NAME | head -1 | cut -d "=" -f2 | tr -d '[:space:]')
+CONTAINER_NAME=${IMAGE_NAME}_container

keypoint-db/ws/compile_and_source.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+
+colcon build --parallel-workers 10
+source /home/user/ws/install/setup.bash
+
+echo "sourced" /home/user/ws/install/setup.bash

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

@@ -0,0 +1 @@
+# ROS2 db_loader package

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

@@ -0,0 +1,346 @@
+#!/usr/bin/env python3
+
+import rclpy
+from rclpy.node import Node
+from db_loader_msgs.msg import Skeleton
+import pandas as pd
+import argparse
+from pathlib import Path
+
+
+class IndexKeypointPublisher(Node):
+    def __init__(self, index_file_path, num_chunks=20, playback_speed=1.0):
+        super().__init__('index_keypoint_publisher')
+        
+        self.publisher = self.create_publisher(
+            Skeleton,
+            'skeleton_data',
+            10
+        )
+        
+        self.playback_speed = playback_speed
+        self.num_chunks = num_chunks
+        self.previous_persons = set()
+        
+        # Get directory containing the index file
+        self.data_dir = Path(index_file_path).parent
+        
+        # Read the index file
+        try:
+            self.index_df = pd.read_csv(index_file_path)
+            self.get_logger().info(f'Successfully loaded index file: {len(self.index_df)} tracks')
+            
+            # Validate required columns
+            required_cols = ['track_id', 'track_start_timestamp', 'track_end_timestamp']
+            missing_cols = [col for col in required_cols if col not in self.index_df.columns]
+            if missing_cols:
+                self.get_logger().error(f'Missing required columns in index: {missing_cols}')
+                self.index_df = None
+                return
+            
+            # Parse timestamps
+            self.index_df['track_start_timestamp'] = pd.to_datetime(
+                self.index_df['track_start_timestamp'], format='ISO8601'
+            )
+            self.index_df['track_end_timestamp'] = pd.to_datetime(
+                self.index_df['track_end_timestamp'], format='ISO8601'
+            )
+            
+            # Calculate global time range
+            global_start = self.index_df['track_start_timestamp'].min()
+            global_end = self.index_df['track_end_timestamp'].max()
+            
+            # Convert to seconds from global start
+            self.index_df['start_seconds'] = (
+                self.index_df['track_start_timestamp'] - global_start
+            ).dt.total_seconds()
+            self.index_df['end_seconds'] = (
+                self.index_df['track_end_timestamp'] - global_start
+            ).dt.total_seconds()
+            
+            # Store timing information
+            self.global_start_timestamp = global_start
+            self.start_time = 0.0
+            self.end_time = float((global_end - global_start).total_seconds())
+            self.current_time = self.start_time
+            
+            self.get_logger().info(f'Global time range: {self.start_time:.2f} to {self.end_time:.2f} seconds')
+            self.get_logger().info(f'Total duration: {self.end_time:.2f} seconds ({self.end_time/60:.1f} minutes)')
+            
+            # Calculate chunk boundaries
+            self.chunk_duration = self.end_time / num_chunks
+            self.chunks = []
+            for i in range(num_chunks):
+                chunk_start = i * self.chunk_duration
+                chunk_end = (i + 1) * self.chunk_duration if i < num_chunks - 1 else self.end_time
+                self.chunks.append({
+                    'start': chunk_start,
+                    'end': chunk_end,
+                    'data': None,
+                    'loaded': False
+                })
+            
+            self.get_logger().info(f'Created {num_chunks} chunks of {self.chunk_duration:.1f}s each')
+            
+            # Current chunk index
+            self.current_chunk_idx = 0
+            self.current_chunk_data = None
+            
+            # Load first chunk
+            self.load_chunk(0)
+            
+            # Create timer for playback (30 Hz)
+            self.update_rate = 30.0
+            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')
+            
+        except FileNotFoundError:
+            self.get_logger().error(f'Index file not found: {index_file_path}')
+            self.index_df = None
+        except Exception as e:
+            self.get_logger().error(f'Failed to load index file: {e}')
+            import traceback
+            self.get_logger().error(traceback.format_exc())
+            self.index_df = None
+    
+    def load_chunk(self, chunk_idx):
+        """Load and merge all tracks that overlap with this chunk"""
+        if chunk_idx >= len(self.chunks):
+            return False
+        
+        chunk = self.chunks[chunk_idx]
+        chunk_start = chunk['start']
+        chunk_end = chunk['end']
+        
+        self.get_logger().info(f'Loading chunk {chunk_idx}: time {chunk_start:.1f}s to {chunk_end:.1f}s')
+        
+        # Find all tracks that overlap with this chunk
+        overlapping_tracks = self.index_df[
+            (self.index_df['start_seconds'] < chunk_end) &
+            (self.index_df['end_seconds'] > chunk_start)
+        ]
+        
+        self.get_logger().info(f'Found {len(overlapping_tracks)} tracks overlapping with chunk {chunk_idx}')
+        
+        # Load and merge all overlapping tracks
+        all_track_data = []
+        
+        for _, track_row in overlapping_tracks.iterrows():
+            track_id = str(track_row['track_id'])
+            csv_path = self.data_dir / f'track_{track_id}.csv'
+            
+            try:
+                df = pd.read_csv(csv_path)
+                
+                # Parse timestamps
+                df['timestamp'] = pd.to_datetime(df['timestamp'], format='ISO8601')
+                
+                # Convert to seconds from global start
+                df['time_seconds'] = (df['timestamp'] - self.global_start_timestamp).dt.total_seconds()
+                
+                # Filter to only include data within this chunk (with small buffer)
+                buffer = 1.0  # 1 second buffer on each side
+                chunk_data = df[
+                    (df['time_seconds'] >= chunk_start - buffer) &
+                    (df['time_seconds'] <= chunk_end + buffer)
+                ]
+                
+                if not chunk_data.empty:
+                    all_track_data.append(chunk_data)
+                    self.get_logger().debug(f'  Track {track_id}: loaded {len(chunk_data)} rows')
+                
+            except Exception as e:
+                self.get_logger().error(f'Failed to load track {track_id}: {e}')
+        
+        if all_track_data:
+            # Merge all track data into single dataframe
+            merged_df = pd.concat(all_track_data, ignore_index=True)
+            
+            # Sort by time
+            merged_df = merged_df.sort_values('time_seconds').reset_index(drop=True)
+            
+            chunk['data'] = merged_df
+            chunk['loaded'] = True
+            
+            self.get_logger().info(
+                f'Chunk {chunk_idx} loaded: {len(merged_df)} total rows, '
+                f'time range: {merged_df["time_seconds"].min():.2f} to {merged_df["time_seconds"].max():.2f}s'
+            )
+            return True
+        else:
+            self.get_logger().warning(f'No data found for chunk {chunk_idx}')
+            chunk['loaded'] = True  # Mark as loaded even if empty
+            return False
+    
+    def publish_callback(self):
+        if self.index_df is None:
+            return
+        
+        # Check if we need to switch to next chunk
+        if self.current_time >= self.chunks[self.current_chunk_idx]['end']:
+            self.get_logger().info(f'Finished chunk {self.current_chunk_idx}')
+            
+            # Unload current chunk to free memory
+            self.chunks[self.current_chunk_idx]['data'] = None
+            
+            # Move to next chunk
+            self.current_chunk_idx += 1
+            
+            if self.current_chunk_idx >= len(self.chunks):
+                # Reached end, loop back
+                self.get_logger().info('Playback finished. Looping...')
+                self.current_chunk_idx = 0
+                self.current_time = self.start_time
+                self.previous_persons = set()
+                self.load_chunk(0)
+            else:
+                # Load next chunk if not already loaded
+                if not self.chunks[self.current_chunk_idx]['loaded']:
+                    self.load_chunk(self.current_chunk_idx)
+        
+        # Preload next chunk when we're near the end of current chunk
+        preload_threshold = 5.0  # Preload 5 seconds before end
+        if (self.current_chunk_idx < len(self.chunks) - 1 and
+            self.current_time >= self.chunks[self.current_chunk_idx]['end'] - preload_threshold):
+            next_chunk_idx = self.current_chunk_idx + 1
+            if not self.chunks[next_chunk_idx]['loaded']:
+                self.get_logger().info(f'Preloading chunk {next_chunk_idx}')
+                self.load_chunk(next_chunk_idx)
+        
+        # Get current chunk data
+        current_chunk = self.chunks[self.current_chunk_idx]
+        if current_chunk['data'] is None or current_chunk['data'].empty:
+            # No data, just advance time
+            time_step = (1.0 / self.update_rate) * self.playback_speed
+            self.current_time += time_step
+            return
+        
+        df = current_chunk['data']
+        
+        # Get all data points at current time (with small time window)
+        time_window = 0.033  # ~30ms window (one frame at 30Hz)
+        current_data = df[
+            (df['time_seconds'] >= self.current_time) & 
+            (df['time_seconds'] < self.current_time + time_window)
+        ]
+        
+        current_persons = set()
+        
+        if not current_data.empty:
+            # Publish a message for each person at this timestamp
+            for idx, row in current_data.iterrows():
+                person_id = str(row['person_track_id'])
+                current_persons.add(person_id)
+                
+                msg = Skeleton()
+                
+                # Basic info
+                msg.person_track_id = person_id
+                msg.timestamp = float(row['time_seconds'])
+                
+                # Define all keypoint fields
+                keypoint_fields = [
+                    'neck_x', 'neck_y', 'neck_z',
+                    'right_shoulder_x', 'right_shoulder_y', 'right_shoulder_z',
+                    'right_elbow_x', 'right_elbow_y', 'right_elbow_z',
+                    'right_wrist_x', 'right_wrist_y', 'right_wrist_z',
+                    'right_hand_x', 'right_hand_y', 'right_hand_z',
+                    'left_shoulder_x', 'left_shoulder_y', 'left_shoulder_z',
+                    'left_elbow_x', 'left_elbow_y', 'left_elbow_z',
+                    'left_wrist_x', 'left_wrist_y', 'left_wrist_z',
+                    'left_hand_x', 'left_hand_y', 'left_hand_z',
+                    'middle_of_waist_x', 'middle_of_waist_y', 'middle_of_waist_z',
+                    'right_hip_x', 'right_hip_y', 'right_hip_z',
+                    'right_knee_x', 'right_knee_y', 'right_knee_z',
+                    'right_ankle_x', 'right_ankle_y', 'right_ankle_z',
+                    'right_foot_x', 'right_foot_y', 'right_foot_z',
+                    'left_hip_x', 'left_hip_y', 'left_hip_z',
+                    'left_knee_x', 'left_knee_y', 'left_knee_z',
+                    'left_ankle_x', 'left_ankle_y', 'left_ankle_z',
+                    'left_foot_x', 'left_foot_y', 'left_foot_z',
+                ]
+                
+                # Set all keypoint values
+                for field in keypoint_fields:
+                    if field in row.index and pd.notna(row[field]):
+                        setattr(msg, field, float(row[field]))
+                    else:
+                        setattr(msg, field, 0.0)
+                
+                # Publish the message
+                self.publisher.publish(msg)
+            
+            self.get_logger().debug(
+                f'Published {len(current_data)} skeleton messages at t={self.current_time:.2f}s '
+                f'(chunk {self.current_chunk_idx})'
+            )
+        
+        # Publish empty messages for persons that left
+        persons_left = self.previous_persons - current_persons
+        for person_id in persons_left:
+            msg = Skeleton()
+            msg.person_track_id = person_id
+            msg.timestamp = -1.0
+            self.publisher.publish(msg)
+            self.get_logger().debug(f'Person {person_id} left the scene')
+        
+        # Update previous persons
+        self.previous_persons = current_persons
+        
+        # Advance time
+        time_step = (1.0 / self.update_rate) * self.playback_speed
+        self.current_time += time_step
+        
+        # Log progress every 10 seconds
+        elapsed_time = self.current_time - self.start_time
+        if int(elapsed_time) % 10 == 0 and int(elapsed_time) != int(elapsed_time - time_step):
+            progress = elapsed_time / (self.end_time - self.start_time) * 100
+            self.get_logger().info(
+                f'Playback: {progress:.1f}% | Time: {elapsed_time:.1f}s | Chunk: {self.current_chunk_idx}/{len(self.chunks)}'
+            )
+
+
+def main(args=None):
+    parser = argparse.ArgumentParser(
+        description='Publish skeleton keypoint data from indexed CSV files'
+    )
+    parser.add_argument(
+        'index_file', 
+        type=str, 
+        help='Path to the index CSV file (e.g., stats.csv)'
+    )
+    parser.add_argument(
+        '--chunks',
+        type=int,
+        default=20,
+        help='Number of time chunks to divide playback into (default: 20)'
+    )
+    parser.add_argument(
+        '--speed', 
+        type=float, 
+        default=1.0,
+        help='Playback speed multiplier (default: 1.0)'
+    )
+    
+    import sys
+    filtered_args = [arg for arg in sys.argv[1:] if not arg.startswith('__')]
+    parsed_args, unknown = parser.parse_known_args(filtered_args)
+    
+    rclpy.init(args=args)
+    node = IndexKeypointPublisher(
+        parsed_args.index_file,
+        parsed_args.chunks,
+        parsed_args.speed
+    )
+    
+    try:
+        rclpy.spin(node)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        node.destroy_node()
+        rclpy.shutdown()
+
+
+if __name__ == '__main__':
+    main()

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

@@ -0,0 +1,630 @@
+#!/usr/bin/env python3
+
+import rclpy
+from rclpy.node import Node
+from visualization_msgs.msg import Marker, MarkerArray
+from geometry_msgs.msg import Point
+import pandas as pd
+import numpy as np
+import argparse
+from pathlib import Path
+
+
+class KeypointPublisher(Node):
+    def __init__(self, csv_file_path=None, index_file_path=None, playback_speed=1.0, publish_rate=30.0, interpolate=False):
+        super().__init__('keypoint_publisher')
+        
+        # Publisher for visualization markers (increased queue size)
+        self.marker_pub = self.create_publisher(
+            MarkerArray,
+            'skeleton_markers',
+            100
+        )
+        
+        self.playback_speed = playback_speed
+        self.interpolate = interpolate
+        self.previous_persons = set()
+        self.timeout = rclpy.duration.Duration(seconds=2.0)
+        
+        # Chunk management
+        self.chunks = []
+        self.current_chunk_idx = 0
+        self.next_chunk_df = None
+        self.preload_threshold = 2.0
+        
+        # Current data
+        self.df = None
+        self.current_time = 0.0
+        self.start_time = 0.0
+        self.end_time = 0.0
+        
+        # Color management for persons
+        self.person_colors = {}
+        self.color_index = 0
+        
+        # Keypoint fields for interpolation
+        self.keypoint_fields = [
+            'neck_x', 'neck_y', 'neck_z',
+            'right_shoulder_x', 'right_shoulder_y', 'right_shoulder_z',
+            'right_elbow_x', 'right_elbow_y', 'right_elbow_z',
+            'right_wrist_x', 'right_wrist_y', 'right_wrist_z',
+            'right_hand_x', 'right_hand_y', 'right_hand_z',
+            'left_shoulder_x', 'left_shoulder_y', 'left_shoulder_z',
+            'left_elbow_x', 'left_elbow_y', 'left_elbow_z',
+            'left_wrist_x', 'left_wrist_y', 'left_wrist_z',
+            'left_hand_x', 'left_hand_y', 'left_hand_z',
+            'middle_of_waist_x', 'middle_of_waist_y', 'middle_of_waist_z',
+            'right_hip_x', 'right_hip_y', 'right_hip_z',
+            'right_knee_x', 'right_knee_y', 'right_knee_z',
+            'right_ankle_x', 'right_ankle_y', 'right_ankle_z',
+            'right_foot_x', 'right_foot_y', 'right_foot_z',
+            'left_hip_x', 'left_hip_y', 'left_hip_z',
+            'left_knee_x', 'left_knee_y', 'left_knee_z',
+            'left_ankle_x', 'left_ankle_y', 'left_ankle_z',
+            'left_foot_x', 'left_foot_y', 'left_foot_z',
+        ]
+        
+        # Keypoint names for visualization
+        self.keypoint_names = [
+            'neck', 'right_shoulder', 'right_elbow', 'right_wrist', 'right_hand',
+            'left_shoulder', 'left_elbow', 'left_wrist', 'left_hand',
+            'middle_of_waist', 'right_hip', 'right_knee', 'right_ankle', 'right_foot',
+            'left_hip', 'left_knee', 'left_ankle', 'left_foot',
+        ]
+        
+        # Define skeleton connections (bones)
+        self.skeleton_connections = [
+            ('neck', 'middle_of_waist'),
+            ('neck', 'right_shoulder'),
+            ('right_shoulder', 'right_elbow'),
+            ('right_elbow', 'right_wrist'),
+            ('right_wrist', 'right_hand'),
+            ('neck', 'left_shoulder'),
+            ('left_shoulder', 'left_elbow'),
+            ('left_elbow', 'left_wrist'),
+            ('left_wrist', 'left_hand'),
+            ('middle_of_waist', 'right_hip'),
+            ('right_hip', 'right_knee'),
+            ('right_knee', 'right_ankle'),
+            ('right_ankle', 'right_foot'),
+            ('middle_of_waist', 'left_hip'),
+            ('left_hip', 'left_knee'),
+            ('left_knee', 'left_ankle'),
+            ('left_ankle', 'left_foot'),
+        ]
+        
+        # Define which keypoints should be larger
+        self.large_keypoints = ['right_shoulder', 'left_shoulder']
+        
+        # Initialize based on mode
+        if index_file_path:
+            self._init_multi_chunk_mode(index_file_path)
+        elif csv_file_path:
+            self._init_single_chunk_mode(csv_file_path)
+        else:
+            self.get_logger().error('Either csv_file or index_file must be provided')
+            return
+        
+        if self.df is not None:
+            # Publish at specified rate
+            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'Interpolation: {"ENABLED" if self.interpolate else "DISABLED"}')
+    
+    def _generate_color(self):
+        """Generate a distinct color for each person"""
+        hue = (self.color_index * 0.618033988749895) % 1.0
+        self.color_index += 1
+        
+        h = hue * 6
+        x = 1.0 - abs((h % 2) - 1.0)
+        
+        if h < 1: r, g, b = 1.0, x, 0.0
+        elif h < 2: r, g, b = x, 1.0, 0.0
+        elif h < 3: r, g, b = 0.0, 1.0, x
+        elif h < 4: r, g, b = 0.0, x, 1.0
+        elif h < 5: r, g, b = x, 0.0, 1.0
+        else: r, g, b = 1.0, 0.0, x
+        
+        return (r, g, b)
+    
+    def _get_nearest_frame(self, person_id, current_time):
+        """Get the nearest frame for a person at the current time (no interpolation)"""
+        # Get data for this person
+        person_data = self.df[self.df['person_track_id'] == person_id].copy()
+        
+        if len(person_data) == 0:
+            return None
+        
+        # Find the nearest timestamp
+        person_data = person_data.sort_values('time_seconds')
+        times = person_data['time_seconds'].values
+        
+        # Find the index of the closest time
+        idx = np.argmin(np.abs(times - current_time))
+        
+        return person_data.iloc[idx]
+    
+    def _interpolate_skeleton(self, person_id, current_time):
+        """Interpolate skeleton keypoints for a person at the current time"""
+        # Get data for this person
+        person_data = self.df[self.df['person_track_id'] == person_id].copy()
+        
+        if len(person_data) == 0:
+            return None
+        
+        # Find the two nearest timestamps (before and after current_time)
+        person_data = person_data.sort_values('time_seconds')
+        times = person_data['time_seconds'].values
+        
+        # Find interpolation indices
+        if current_time <= times[0]:
+            # Before first point, use first frame
+            return person_data.iloc[0]
+        elif current_time >= times[-1]:
+            # After last point, use last frame
+            return person_data.iloc[-1]
+        else:
+            # Interpolate between two frames
+            idx_after = np.searchsorted(times, current_time)
+            idx_before = idx_after - 1
+            
+            time_before = times[idx_before]
+            time_after = times[idx_after]
+            
+            # Calculate interpolation weight
+            alpha = (current_time - time_before) / (time_after - time_before)
+            
+            # Get the two frames
+            frame_before = person_data.iloc[idx_before]
+            frame_after = person_data.iloc[idx_after]
+            
+            # Create interpolated frame
+            interpolated = frame_before.copy()
+            interpolated['time_seconds'] = current_time
+            
+            # Interpolate all keypoint fields
+            for field in self.keypoint_fields:
+                if field in frame_before.index and field in frame_after.index:
+                    val_before = frame_before[field]
+                    val_after = frame_after[field]
+                    
+                    # Only interpolate if both values are valid (not NaN and not 0)
+                    if pd.notna(val_before) and pd.notna(val_after):
+                        if val_before != 0.0 or val_after != 0.0:
+                            interpolated[field] = val_before * (1 - alpha) + val_after * alpha
+            
+            return interpolated
+    
+    def _get_frame_for_person(self, person_id, current_time):
+        """Get frame for person - either nearest or interpolated based on settings"""
+        if self.interpolate:
+            return self._interpolate_skeleton(person_id, current_time)
+        else:
+            return self._get_nearest_frame(person_id, current_time)
+    
+    def _get_keypoint_position(self, frame, keypoint_name):
+        """Extract (x, y, z) position for a given keypoint from frame"""
+        x = frame.get(f'{keypoint_name}_x', 0.0)
+        y = frame.get(f'{keypoint_name}_y', 0.0)
+        z = frame.get(f'{keypoint_name}_z', 0.0)
+        
+        if pd.isna(x) or pd.isna(y) or pd.isna(z):
+            return None
+        if x == 0.0 and y == 0.0 and z == 0.0:
+            return None
+            
+        return (float(x), float(y), float(z))
+    
+    def _create_markers_for_person(self, person_id, frame, publish_timestamp):
+        """Create all markers (keypoints, bones, labels) for a single person"""
+        markers = []
+        
+        if person_id not in self.person_colors:
+            self.person_colors[person_id] = self._generate_color()
+            self.get_logger().info(f'New person detected: {person_id}')
+        
+        color = self.person_colors[person_id]
+        marker_id_counter = 0
+        
+        # Extract all keypoint positions
+        keypoint_positions = {}
+        for keypoint_name in self.keypoint_names:
+            pos = self._get_keypoint_position(frame, keypoint_name)
+            if pos is not None:
+                keypoint_positions[keypoint_name] = pos
+        
+        # Create sphere markers for keypoints
+        for keypoint_name, pos in keypoint_positions.items():
+            marker_scale = 0.1 if keypoint_name in self.large_keypoints else 0.05
+            
+            marker = Marker()
+            marker.header.frame_id = "map"
+            marker.header.stamp = self.get_clock().now().to_msg()
+            marker.ns = f"keypoints_{person_id}"
+            marker.id = marker_id_counter
+            marker.type = Marker.SPHERE
+            marker.action = Marker.ADD
+            marker.lifetime = self.timeout.to_msg()
+            
+            marker.pose.position.x, marker.pose.position.y, marker.pose.position.z = pos
+            marker.pose.orientation.w = 1.0
+            
+            marker.scale.x = marker.scale.y = marker.scale.z = marker_scale
+            marker.color.r, marker.color.g, marker.color.b = color
+            marker.color.a = 1.0
+            
+            markers.append(marker)
+            marker_id_counter += 1
+        
+        # Create line markers for bones
+        if keypoint_positions:
+            line_marker = Marker()
+            line_marker.header.frame_id = "map"
+            line_marker.header.stamp = self.get_clock().now().to_msg()
+            line_marker.ns = f"bones_{person_id}"
+            line_marker.id = 0
+            line_marker.type = Marker.LINE_LIST
+            line_marker.action = Marker.ADD
+            line_marker.lifetime = self.timeout.to_msg()
+            
+            for joint1, joint2 in self.skeleton_connections:
+                if joint1 in keypoint_positions and joint2 in keypoint_positions:
+                    p1_tuple, p2_tuple = keypoint_positions[joint1], keypoint_positions[joint2]
+                    
+                    p1, p2 = Point(), Point()
+                    p1.x, p1.y, p1.z = p1_tuple
+                    p2.x, p2.y, p2.z = p2_tuple
+                    line_marker.points.append(p1)
+                    line_marker.points.append(p2)
+            
+            line_marker.scale.x = 0.02
+            line_marker.color.r, line_marker.color.g, line_marker.color.b = color
+            line_marker.color.a = 0.8
+            
+            if line_marker.points:
+                markers.append(line_marker)
+        
+        # Create text label for person ID
+        if 'neck' in keypoint_positions:
+            neck_pos = keypoint_positions['neck']
+            
+            text_marker = Marker()
+            text_marker.header.frame_id = "map"
+            text_marker.header.stamp = self.get_clock().now().to_msg()
+            text_marker.ns = f"labels_{person_id}"
+            text_marker.id = 0
+            text_marker.type = Marker.TEXT_VIEW_FACING
+            text_marker.action = Marker.ADD
+            text_marker.lifetime = self.timeout.to_msg()
+            
+            text_marker.pose.position.x = neck_pos[0]
+            text_marker.pose.position.y = neck_pos[1]
+            text_marker.pose.position.z = neck_pos[2] + 0.5  # Display slightly above the neck
+            
+            text_marker.text = f"ID: {person_id}"
+            text_marker.scale.z = 0.15  # Text height
+            
+            text_marker.color.r = 1.0
+            text_marker.color.g = 1.0
+            text_marker.color.b = 1.0
+            text_marker.color.a = 1.0
+            
+            markers.append(text_marker)
+        
+        return markers
+    
+    def _init_multi_chunk_mode(self, index_file_path):
+        """Initialize multi-chunk playback mode from index file"""
+        try:
+            index_df = pd.read_csv(index_file_path)
+            self.get_logger().info(f'Loaded index file: {index_file_path}')
+            self.get_logger().info(f'Found {len(index_df)} chunks')
+            
+            # Validate required columns
+            required_cols = ['chunk_key', 'chunk_start_timestamp', 'chunk_end_timestamp']
+            missing_cols = [col for col in required_cols if col not in index_df.columns]
+            if missing_cols:
+                self.get_logger().error(f'Missing required columns in index: {missing_cols}')
+                return
+            
+            # Parse timestamps and sort by start time
+            index_df['chunk_start_timestamp'] = pd.to_datetime(index_df['chunk_start_timestamp'])
+            index_df['chunk_end_timestamp'] = pd.to_datetime(index_df['chunk_end_timestamp'])
+            index_df = index_df.sort_values('chunk_start_timestamp').reset_index(drop=True)
+            
+            # Get base directory from index file path
+            base_dir = Path(index_file_path).parent
+            
+            # Store chunk information
+            for _, row in index_df.iterrows():
+                chunk_key = row['chunk_key']
+                filename = f"chunk_{chunk_key}"
+                chunk_path = base_dir / f"{filename}.csv"
+                self.chunks.append({
+                    'path': str(chunk_path),
+                    'key': chunk_key,
+                    'filename': filename,
+                    'start': row['chunk_start_timestamp'],
+                    'end': row['chunk_end_timestamp']
+                })
+            
+            self.get_logger().info(f'Chunk playback order:')
+            for i, chunk in enumerate(self.chunks):
+                self.get_logger().info(f'  {i+1}. {chunk["filename"]}.csv')
+            
+            # Load first chunk
+            if not self._load_chunk(0):
+                self.get_logger().error('Failed to load first chunk')
+                return
+                
+        except Exception as e:
+            self.get_logger().error(f'Failed to initialize multi-chunk mode: {e}')
+            import traceback
+            self.get_logger().error(traceback.format_exc())
+    
+    def _init_single_chunk_mode(self, csv_file_path):
+        """Initialize single chunk playback mode (original behavior)"""
+        self.get_logger().info('Single chunk mode')
+        self._load_csv_data(csv_file_path)
+    
+    def _load_chunk(self, chunk_idx):
+        """Load a specific chunk by index"""
+        if chunk_idx >= len(self.chunks):
+            return False
+        
+        chunk = self.chunks[chunk_idx]
+        self.get_logger().info(f'Loading chunk {chunk_idx + 1}/{len(self.chunks)}: {chunk["filename"]}')
+        
+        if self._load_csv_data(chunk['path']):
+            self.current_chunk_idx = chunk_idx
+            return True
+        return False
+    
+    def _preload_next_chunk(self):
+        """Preload the next chunk in background"""
+        next_idx = self.current_chunk_idx + 1
+        if next_idx >= len(self.chunks) or self.next_chunk_df is not None:
+            return
+        
+        chunk = self.chunks[next_idx]
+        self.get_logger().info(f'Preloading next chunk: {chunk["filename"]}')
+        
+        try:
+            df = pd.read_csv(chunk['path'])
+            
+            # Process timestamps
+            if not pd.api.types.is_datetime64_any_dtype(df['timestamp']):
+                try:
+                    df['timestamp'] = pd.to_datetime(df['timestamp'], format='ISO8601')
+                except:
+                    try:
+                        df['timestamp'] = pd.to_datetime(df['timestamp'], format='mixed')
+                    except:
+                        df['timestamp'] = pd.to_datetime(df['timestamp'])
+            
+            # Convert to seconds from start
+            df['time_seconds'] = (df['timestamp'] - df['timestamp'].min()).dt.total_seconds()
+            df = df.sort_values('time_seconds').reset_index(drop=True)
+            
+            self.next_chunk_df = df
+            self.get_logger().info(f'Preloaded chunk {chunk["filename"]}: {len(df)} rows')
+            
+        except Exception as e:
+            self.get_logger().error(f'Failed to preload chunk {chunk["filename"]}: {e}')
+    
+    def _switch_to_next_chunk(self):
+        """Switch to the preloaded next chunk"""
+        if self.next_chunk_df is None:
+            if self.current_chunk_idx + 1 < len(self.chunks):
+                if not self._load_chunk(self.current_chunk_idx + 1):
+                    self.get_logger().warn('No more chunks to play')
+                    return False
+            else:
+                self.get_logger().info('All chunks played. Looping to first chunk...')
+                self._load_chunk(0)
+                return True
+        else:
+            self.df = self.next_chunk_df
+            self.next_chunk_df = None
+            self.current_chunk_idx += 1
+            
+            self.start_time = float(self.df['time_seconds'].min())
+            self.end_time = float(self.df['time_seconds'].max())
+            self.current_time = self.start_time
+            self.previous_persons = set()
+            
+            chunk = self.chunks[self.current_chunk_idx]
+            self.get_logger().info(f'Switched to chunk {self.current_chunk_idx + 1}/{len(self.chunks)}: {chunk["filename"]}')
+            self.get_logger().info(f'Duration: {self.end_time - self.start_time:.2f} seconds')
+        
+        return True
+    
+    def _load_csv_data(self, csv_file_path):
+        """Load CSV data from file"""
+        try:
+            df = pd.read_csv(csv_file_path)
+            self.get_logger().info(f'Successfully loaded: {Path(csv_file_path).name} ({len(df)} rows)')
+            
+            # Validate required columns
+            required_cols = ['timestamp', 'person_track_id']
+            missing_cols = [col for col in required_cols if col not in df.columns]
+            if missing_cols:
+                self.get_logger().error(f'Missing required columns: {missing_cols}')
+                return False
+            
+            # Convert timestamp to datetime
+            if not pd.api.types.is_datetime64_any_dtype(df['timestamp']):
+                self.get_logger().info('Converting timestamp to datetime...')
+                try:
+                    df['timestamp'] = pd.to_datetime(df['timestamp'], format='ISO8601')
+                except:
+                    try:
+                        df['timestamp'] = pd.to_datetime(df['timestamp'], format='mixed')
+                    except:
+                        df['timestamp'] = pd.to_datetime(df['timestamp'])
+                
+                self.get_logger().info('Successfully parsed timestamps')
+            
+            # Convert to seconds from start
+            df['time_seconds'] = (df['timestamp'] - df['timestamp'].min()).dt.total_seconds()
+            
+            # Sort by time
+            df = df.sort_values('time_seconds').reset_index(drop=True)
+            
+            # Store data
+            self.df = df
+            self.start_time = float(df['time_seconds'].min())
+            self.end_time = float(df['time_seconds'].max())
+            self.current_time = self.start_time
+            
+            self.get_logger().info(f'Time range: {self.start_time:.2f} to {self.end_time:.2f} seconds')
+            self.get_logger().info(f'Duration: {self.end_time - self.start_time:.2f} seconds')
+            self.get_logger().info(f'Unique persons: {df["person_track_id"].nunique()}')
+            
+            return True
+            
+        except FileNotFoundError:
+            self.get_logger().error(f'CSV file not found: {csv_file_path}')
+            return False
+        except Exception as e:
+            self.get_logger().error(f'Failed to load CSV file: {e}')
+            import traceback
+            self.get_logger().error(traceback.format_exc())
+            return False
+    
+    def publish_callback(self):
+        if self.df is None:
+            return
+        
+        # Check if we need to preload next chunk
+        if self.chunks and self.next_chunk_df is None:
+            time_remaining = self.end_time - self.current_time
+            if time_remaining <= self.preload_threshold:
+                self._preload_next_chunk()
+        
+        # Use the EXACT same timestamp for all tracks in this update cycle
+        publish_timestamp = float(self.current_time)
+        
+        # Get all unique persons that exist in a window around current time
+        time_window = 0.5  # Look ahead/behind 0.5 seconds to find all active persons
+        nearby_data = self.df[
+            (self.df['time_seconds'] >= self.current_time - time_window) & 
+            (self.df['time_seconds'] <= self.current_time + time_window)
+        ]
+        
+        current_persons = set()
+        marker_array = MarkerArray()
+        
+        if not nearby_data.empty:
+            # Get all unique persons in this time window
+            unique_persons = nearby_data['person_track_id'].unique()
+            
+            # For each person, get frame and create markers
+            for person_id in unique_persons:
+                person_id_str = str(person_id)
+                current_persons.add(person_id_str)
+                
+                # Get frame for person (interpolated or nearest based on settings)
+                frame = self._get_frame_for_person(person_id, self.current_time)
+                
+                if frame is not None:
+                    # Create all markers for this person
+                    person_markers = self._create_markers_for_person(
+                        person_id_str, 
+                        frame, 
+                        publish_timestamp
+                    )
+                    marker_array.markers.extend(person_markers)
+            
+            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')
+        
+        # Create deletion markers for persons that left
+        persons_left = self.previous_persons - current_persons
+        for person_id in persons_left:
+            self.get_logger().info(f'Person {person_id} left the scene')
+            
+            # Delete keypoints
+            delete_marker = Marker()
+            delete_marker.action = Marker.DELETEALL
+            delete_marker.ns = f"keypoints_{person_id}"
+            marker_array.markers.append(delete_marker)
+            
+            # Delete bones
+            delete_marker_bones = Marker()
+            delete_marker_bones.action = Marker.DELETEALL
+            delete_marker_bones.ns = f"bones_{person_id}"
+            marker_array.markers.append(delete_marker_bones)
+            
+            # Delete labels
+            delete_marker_labels = Marker()
+            delete_marker_labels.action = Marker.DELETEALL
+            delete_marker_labels.ns = f"labels_{person_id}"
+            marker_array.markers.append(delete_marker_labels)
+        
+        # Publish all markers at once
+        if marker_array.markers:
+            self.marker_pub.publish(marker_array)
+        
+        # Update previous persons
+        self.previous_persons = current_persons
+        
+        # Advance time
+        time_step = (1.0 / self.update_rate) * self.playback_speed
+        self.current_time += time_step
+        
+        # Check if we've reached the end
+        if self.current_time > self.end_time:
+            if self.chunks:
+                if not self._switch_to_next_chunk():
+                    self.get_logger().info('Playback finished.')
+            else:
+                self.get_logger().info('Playback finished. Looping...')
+                self.current_time = self.start_time
+                self.previous_persons = set()
+
+
+def main(args=None):
+    parser = argparse.ArgumentParser(
+        description='Publish skeleton keypoint visualization markers from CSV file(s)')
+    parser.add_argument('csv_file', type=str, nargs='?', 
+                       help='Path to a single CSV file with keypoint data')
+    parser.add_argument('--index', type=str, 
+                       help='Path to index CSV file for multi-chunk playback')
+    parser.add_argument('--speed', type=float, default=1.0, 
+                       help='Playback speed multiplier (default: 1.0)')
+    parser.add_argument('--rate', type=float, default=30.0,
+                       help='Publishing rate in Hz (default: 10.0)')
+    parser.add_argument('--interpolate', action='store_true',
+                       help='Enable linear interpolation between frames (default: disabled)')
+    
+    import sys
+    filtered_args = [arg for arg in sys.argv[1:] if not arg.startswith('__')]
+    parsed_args, unknown = parser.parse_known_args(filtered_args)
+    
+    if not parsed_args.csv_file and not parsed_args.index:
+        parser.error('Either csv_file or --index must be provided')
+    
+    rclpy.init(args=args)
+    node = KeypointPublisher(
+        csv_file_path=parsed_args.csv_file,
+        index_file_path=parsed_args.index,
+        playback_speed=parsed_args.speed,
+        publish_rate=parsed_args.rate,
+        interpolate=parsed_args.interpolate
+    )
+    
+    try:
+        rclpy.spin(node)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        node.destroy_node()
+        rclpy.shutdown()
+
+
+if __name__ == '__main__':
+    main()

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

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+
+import rclpy
+from rclpy.node import Node
+from std_msgs.msg import String
+import json
+import argparse
+
+
+class LayoutPublisher(Node):
+    def __init__(self, json_file_path, rate=None):
+        super().__init__('layout_publisher')
+        self.publisher = self.create_publisher(String, 'layout_data', 10)
+        self.continuous = rate is not None
+        
+        # Read the JSON file
+        try:
+            with open(json_file_path, 'r') as f:
+                self.layout_data = json.load(f)
+            self.get_logger().info(f'Successfully loaded layout JSON file: {json_file_path}')
+            
+            if self.continuous:
+                # Publish continuously at specified rate
+                self.get_logger().info(f'Publishing continuously at {rate} Hz')
+                self.timer = self.create_timer(1.0 / rate, self.publish_layout)
+            else:
+                # Publish once after a short delay
+                self.get_logger().info('Publishing once')
+                self.timer = self.create_timer(0.5, self.publish_once)
+                
+        except FileNotFoundError:
+            self.get_logger().error(f'JSON file not found: {json_file_path}')
+            self.layout_data = None
+        except json.JSONDecodeError as e:
+            self.get_logger().error(f'Failed to parse JSON: {e}')
+            self.layout_data = None
+    
+    def publish_layout(self):
+        """Publish continuously"""
+        if self.layout_data is None:
+            self.get_logger().warn('No layout data to publish')
+            return
+        
+        msg = String()
+        msg.data = json.dumps(self.layout_data)
+        self.publisher.publish(msg)
+        self.get_logger().info(f'Published layout data for: {self.layout_data.get("name", "Unknown")}')
+    
+    def publish_once(self):
+        """Publish once and shutdown"""
+        if self.layout_data is None:
+            self.get_logger().error('No layout data to publish')
+            rclpy.shutdown()
+            return
+        
+        msg = String()
+        msg.data = json.dumps(self.layout_data)
+        self.publisher.publish(msg)
+        self.get_logger().info(f'Published layout data for: {self.layout_data.get("name", "Unknown")}')
+        
+        # Cancel timer and shutdown
+        self.timer.cancel()
+        rclpy.shutdown()
+
+
+def main(args=None):
+    parser = argparse.ArgumentParser(description='Publish layout JSON data to ROS 2 topic')
+    parser.add_argument('json_file', type=str, help='Path to the JSON layout file')
+    parser.add_argument('--rate', type=float, default=None, 
+                       help='Publishing rate in Hz. If not specified, publishes once and exits')
+    
+    import sys
+    filtered_args = [arg for arg in sys.argv[1:] if not arg.startswith('__')]
+    
+    # Use parse_known_args instead of parse_args to ignore ROS arguments
+    parsed_args, unknown = parser.parse_known_args(filtered_args)
+    
+    rclpy.init(args=args)
+    node = LayoutPublisher(parsed_args.json_file, parsed_args.rate)
+    
+    try:
+        rclpy.spin(node)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        node.destroy_node()
+        rclpy.shutdown()
+
+
+if __name__ == '__main__':
+    main()

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

@@ -0,0 +1,407 @@
+#!/usr/bin/env python3
+
+import rclpy
+from rclpy.node import Node
+from std_msgs.msg import String
+from visualization_msgs.msg import Marker, MarkerArray
+from geometry_msgs.msg import Point
+import json
+import numpy as np
+
+
+class LayoutVisualizer(Node):
+    def __init__(self, use_filled_shelves=False, shelf_alpha=0.3):
+        super().__init__('layout_visualizer')
+        
+        self.use_filled_shelves = use_filled_shelves
+        self.shelf_alpha = shelf_alpha
+        
+        self.subscription = self.create_subscription(
+            String,
+            'layout_data',
+            self.layout_callback,
+            10
+        )
+        
+        self.marker_pub = self.create_publisher(
+            MarkerArray,
+            'layout_markers',
+            10
+        )
+        
+        self.get_logger().info(f'Layout visualizer started! Filled shelves: {use_filled_shelves}, Alpha: {shelf_alpha}')
+    
+    def layout_callback(self, msg):
+        try:
+            layout = json.loads(msg.data)
+            self.get_logger().info(f'Received layout: {layout.get("name", "Unknown")}')
+            
+            # Create marker array
+            marker_array = MarkerArray()
+            marker_id = 0
+            
+            # Visualize perimeters
+            if 'perimeters' in layout:
+                for perimeter in layout['perimeters']:
+                    marker = self.create_perimeter_marker(perimeter, marker_id)
+                    marker_array.markers.append(marker)
+                    marker_id += 1
+            
+            # Visualize exits
+            if 'exits' in layout:
+                for exit_data in layout['exits']:
+                    marker = self.create_exit_marker(exit_data, marker_id)
+                    marker_array.markers.append(marker)
+                    marker_id += 1
+            
+            # Visualize shelves
+            if 'shelves' in layout:
+                for shelf in layout['shelves']:
+                    # Pass marker_id and get back the updated marker_id
+                    markers, marker_id = self.create_shelf_markers(shelf, marker_id)
+                    marker_array.markers.extend(markers)
+            
+            # Publish markers
+            self.marker_pub.publish(marker_array)
+            self.get_logger().info(f'Published {len(marker_array.markers)} markers')
+            
+        except json.JSONDecodeError as e:
+            self.get_logger().error(f'Failed to parse JSON: {e}')
+        except Exception as e:
+            self.get_logger().error(f'An unexpected error occurred in layout_callback: {e}')
+            import traceback
+            self.get_logger().error(traceback.format_exc())
+    
+    def create_perimeter_marker(self, perimeter, marker_id):
+        marker = Marker()
+        marker.header.frame_id = "map"
+        marker.header.stamp = self.get_clock().now().to_msg()
+        marker.ns = "perimeters"
+        marker.id = marker_id
+        marker.type = Marker.LINE_STRIP
+        marker.action = Marker.ADD
+        marker.lifetime = rclpy.duration.Duration(seconds=0).to_msg()
+        
+        # Set color based on perimeter type
+        perimeter_type = perimeter.get('perimeter_type', '')
+        if perimeter_type == 'tracking_area':
+            marker.color.r = 0.0
+            marker.color.g = 0.0
+            marker.color.b = 0.0
+            marker.color.a = 1.0
+            marker.scale.x = 0.05
+        elif perimeter_type == 'payment_area':
+            marker.color.r = 1.0
+            marker.color.g = 0.0
+            marker.color.b = 0.0
+            marker.color.a = 0.5
+            marker.scale.x = 0.03
+        elif perimeter_type == 'employee_area':
+            marker.color.r = 1.0
+            marker.color.g = 1.0
+            marker.color.b = 0.0
+            marker.color.a = 0.5
+            marker.scale.x = 0.03
+        else:
+            marker.color.r = 0.5
+            marker.color.g = 0.5
+            marker.color.b = 0.5
+            marker.color.a = 0.5
+            marker.scale.x = 0.02
+        
+        # Add points
+        for coord in perimeter['geometry']:
+            p = Point()
+            p.x = float(coord[0])
+            p.y = float(coord[1])
+            p.z = float(coord[2])
+            marker.points.append(p)
+        
+        # Close the loop
+        if marker.points:
+            marker.points.append(marker.points[0])
+        
+        return marker
+    
+    def create_exit_marker(self, exit_data, marker_id):
+        marker = Marker()
+        marker.header.frame_id = "map"
+        marker.header.stamp = self.get_clock().now().to_msg()
+        marker.ns = "exits"
+        marker.id = marker_id
+        marker.type = Marker.LINE_STRIP
+        marker.action = Marker.ADD
+        marker.lifetime = rclpy.duration.Duration(seconds=0).to_msg()
+        
+        # Set color based on exit type
+        exit_type = exit_data.get('exit_type', '')
+        if exit_type == 'employee_only':
+            marker.color.r = 1.0
+            marker.color.g = 0.5
+            marker.color.b = 0.0
+        elif exit_type == 'emergency':
+            marker.color.r = 1.0
+            marker.color.g = 0.0
+            marker.color.b = 0.0
+        else:
+            marker.color.r = 0.0
+            marker.color.g = 1.0
+            marker.color.b = 0.0
+        
+        marker.color.a = 0.8
+        marker.scale.x = 0.08
+        
+        # Add points
+        for coord in exit_data['geometry']:
+            p = Point()
+            p.x = float(coord[0])
+            p.y = float(coord[1])
+            p.z = float(coord[2])
+            marker.points.append(p)
+        
+        # Close the loop
+        if marker.points:
+            marker.points.append(marker.points[0])
+        
+        return marker
+    
+
+    def create_shelf_markers(self, shelf, start_marker_id):
+        """Create markers for a shelf and return them with the next available marker ID"""
+        markers = []
+        marker_id = start_marker_id
+        
+        # Color based on shelf type
+        shelf_type = shelf.get('type', '')
+        if shelf_type == 'shelf':
+            r, g, b = 0.0, 0.5, 1.0
+        elif shelf_type == 'behind_billing_counter':
+            r, g, b = 0.8, 0.2, 0.8
+        elif shelf_type == 'non_merchandise':
+            r, g, b = 0.5, 0.5, 0.5
+        else:
+            r, g, b = 0.0, 0.7, 1.0
+        
+        vertices = shelf['shelf_bounds']['vertices']
+        
+        if self.use_filled_shelves:
+            # Create filled CUBE marker with proper orientation
+            cube_marker = Marker()
+            cube_marker.header.frame_id = "map"
+            cube_marker.header.stamp = self.get_clock().now().to_msg()
+            cube_marker.ns = "shelves_filled"
+            cube_marker.id = marker_id
+            cube_marker.type = Marker.CUBE
+            cube_marker.action = Marker.ADD
+            cube_marker.lifetime = rclpy.duration.Duration(seconds=0).to_msg()
+            
+            # Set position (center of the shelf)
+            center = shelf['shelf_bounds']['center']
+            cube_marker.pose.position.x = float(center[0])
+            cube_marker.pose.position.y = float(center[1])
+            cube_marker.pose.position.z = float(center[2])
+            
+            # Calculate orientation from shelf normal
+            # The shelf normal points outward from the front face
+            # Default cube has depth in Y direction, so we align Y with the normal
+            normal = np.array(shelf['normal'])
+            normal = normal / np.linalg.norm(normal)  # Normalize
+            
+            # Default cube orientation has depth (Y axis) pointing in +Y direction
+            # We need to find the rotation that aligns +Y with the shelf normal
+            default_direction = np.array([0.0, 1.0, 0.0])  # Default cube depth direction (Y)
+            
+            # Calculate rotation axis (cross product)
+            rotation_axis = np.cross(default_direction, normal)
+            rotation_axis_length = np.linalg.norm(rotation_axis)
+            
+            if rotation_axis_length < 1e-6:
+                # Vectors are parallel or anti-parallel
+                if np.dot(default_direction, normal) > 0:
+                    # Same direction, no rotation needed
+                    cube_marker.pose.orientation.w = 1.0
+                    cube_marker.pose.orientation.x = 0.0
+                    cube_marker.pose.orientation.y = 0.0
+                    cube_marker.pose.orientation.z = 0.0
+                else:
+                    # Opposite direction, rotate 180 degrees around X axis
+                    cube_marker.pose.orientation.w = 0.0
+                    cube_marker.pose.orientation.x = 1.0
+                    cube_marker.pose.orientation.y = 0.0
+                    cube_marker.pose.orientation.z = 0.0
+            else:
+                # Normalize rotation axis
+                rotation_axis = rotation_axis / rotation_axis_length
+                
+                # Calculate rotation angle
+                rotation_angle = np.arccos(np.clip(np.dot(default_direction, normal), -1.0, 1.0))
+                
+                # Convert to quaternion
+                half_angle = rotation_angle / 2.0
+                sin_half = np.sin(half_angle)
+                
+                cube_marker.pose.orientation.w = float(np.cos(half_angle))
+                cube_marker.pose.orientation.x = float(rotation_axis[0] * sin_half)
+                cube_marker.pose.orientation.y = float(rotation_axis[1] * sin_half)
+                cube_marker.pose.orientation.z = float(rotation_axis[2] * sin_half)
+            
+            # Set size (dimensions of the shelf)
+            # X = width (along the shelf), Y = depth (perpendicular to face), Z = height
+            extends = shelf['shelf_bounds']['extends']
+            cube_marker.scale.x = float(extends[0] * 2)  # width
+            cube_marker.scale.y = float(extends[1] * 2)  # depth (aligned with normal)
+            cube_marker.scale.z = float(extends[2] * 2)  # height
+            
+            # Set color with transparency
+            cube_marker.color.r = r
+            cube_marker.color.g = g
+            cube_marker.color.b = b
+            cube_marker.color.a = self.shelf_alpha
+            
+            markers.append(cube_marker)
+            marker_id += 1
+        else:
+            # Create wireframe LINE_LIST marker
+            box_marker = Marker()
+            box_marker.header.frame_id = "map"
+            box_marker.header.stamp = self.get_clock().now().to_msg()
+            box_marker.ns = "shelves_box"
+            box_marker.id = marker_id
+            box_marker.type = Marker.LINE_LIST
+            box_marker.action = Marker.ADD
+            box_marker.lifetime = rclpy.duration.Duration(seconds=0).to_msg()
+            box_marker.scale.x = 0.04
+            box_marker.color.r = r
+            box_marker.color.g = g
+            box_marker.color.b = b
+            box_marker.color.a = 0.7
+            
+            # Helper function to add an edge
+            def add_edge(idx1, idx2):
+                if idx1 < len(vertices) and idx2 < len(vertices):
+                    p1 = Point()
+                    p1.x = float(vertices[idx1][0])
+                    p1.y = float(vertices[idx1][1])
+                    p1.z = float(vertices[idx1][2])
+                    
+                    p2 = Point()
+                    p2.x = float(vertices[idx2][0])
+                    p2.y = float(vertices[idx2][1])
+                    p2.z = float(vertices[idx2][2])
+                    
+                    box_marker.points.append(p1)
+                    box_marker.points.append(p2)
+            
+            # Draw all 12 edges of the box
+            # Bottom face
+            add_edge(0, 1)
+            add_edge(1, 2)
+            add_edge(2, 3)
+            add_edge(3, 0)
+            
+            # Top face
+            add_edge(4, 5)
+            add_edge(5, 6)
+            add_edge(6, 7)
+            add_edge(7, 4)
+            
+            # Vertical edges
+            add_edge(0, 4)
+            add_edge(1, 5)
+            add_edge(2, 6)
+            add_edge(3, 7)
+            
+            markers.append(box_marker)
+            marker_id += 1
+        
+        # Shelf normal (arrow showing front face)
+        normal_marker = Marker()
+        normal_marker.header.frame_id = "map"
+        normal_marker.header.stamp = self.get_clock().now().to_msg()
+        normal_marker.ns = "shelf_normals"
+        normal_marker.id = marker_id
+        normal_marker.type = Marker.ARROW
+        normal_marker.action = Marker.ADD
+        normal_marker.lifetime = rclpy.duration.Duration(seconds=0).to_msg()
+        
+        center = shelf['shelf_bounds']['center']
+        normal = shelf['normal']
+        
+        start = Point()
+        start.x = float(center[0])
+        start.y = float(center[1])
+        start.z = float(center[2])
+        
+        end = Point()
+        end.x = float(center[0] + 0.3 * normal[0])
+        end.y = float(center[1] + 0.3 * normal[1])
+        end.z = float(center[2] + 0.3 * normal[2])
+        
+        normal_marker.points = [start, end]
+        normal_marker.scale.x = 0.03
+        normal_marker.scale.y = 0.06
+        normal_marker.scale.z = 0.08
+        
+        normal_marker.color.r = 0.0
+        normal_marker.color.g = 0.0
+        normal_marker.color.b = 1.0
+        normal_marker.color.a = 0.8
+        
+        markers.append(normal_marker)
+        marker_id += 1
+        
+        # Shelf ID text
+        text_marker = Marker()
+        text_marker.header.frame_id = "map"
+        text_marker.header.stamp = self.get_clock().now().to_msg()
+        text_marker.ns = "shelf_labels"
+        text_marker.id = marker_id
+        text_marker.type = Marker.TEXT_VIEW_FACING
+        text_marker.action = Marker.ADD
+        text_marker.lifetime = rclpy.duration.Duration(seconds=0).to_msg()
+        
+        text_marker.pose.position.x = float(center[0])
+        text_marker.pose.position.y = float(center[1])
+        text_marker.pose.position.z = float(center[2]) + 0.3
+        
+        text_marker.text = str(shelf['shelf_id'])
+        text_marker.scale.z = 0.3
+        
+        text_marker.color.r = 1.0
+        text_marker.color.g = 1.0
+        text_marker.color.b = 1.0
+        text_marker.color.a = 1.0
+        
+        markers.append(text_marker)
+        marker_id += 1
+        
+        return markers, marker_id
+
+
+def main(args=None):
+    import argparse
+    import sys
+    
+    parser = argparse.ArgumentParser(description='Visualize layout data')
+    parser.add_argument('--filled', action='store_true', 
+                       help='Display shelves as filled transparent boxes')
+    parser.add_argument('--alpha', type=float, default=0.3,
+                       help='Transparency level for filled shelves (0.0-1.0, default: 0.3)')
+    
+    filtered_args = [arg for arg in sys.argv[1:] if not arg.startswith('__')]
+    parsed_args, unknown = parser.parse_known_args(filtered_args)
+    
+    rclpy.init(args=args)
+    node = LayoutVisualizer(use_filled_shelves=parsed_args.filled, shelf_alpha=parsed_args.alpha)
+    
+    try:
+        rclpy.spin(node)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        node.destroy_node()
+        rclpy.shutdown()
+
+
+if __name__ == '__main__':
+    main()

keypoint-db/ws/src/db_loader/launch/layout_visualization_launch.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+
+from launch import LaunchDescription
+from launch.actions import DeclareLaunchArgument, TimerAction
+from launch.conditions import IfCondition
+from launch.substitutions import LaunchConfiguration, PythonExpression
+from launch_ros.actions import Node
+
+
+def generate_launch_description():
+    # Declare launch arguments
+    json_file_arg = DeclareLaunchArgument(
+        'json_file',
+        default_value='',
+        description='Path to the JSON layout file'
+    )
+    
+    rviz_config_arg = DeclareLaunchArgument(
+        'rviz_config',
+        default_value='/home/user/ws/src/db_loader/rviz/layout_view.rviz',
+        description='Path to RViz config file (leave empty to skip RViz)'
+    )
+    
+    publisher_delay_arg = DeclareLaunchArgument(
+        'publisher_delay',
+        default_value='1.5',
+        description='Delay in seconds before starting publishers (to let subscribers connect)'
+    )
+   
+    filled_shelves_arg = DeclareLaunchArgument(
+        'filled',
+        default_value='true',
+        description='Display shelves as filled transparent boxes (true/false)'
+    )
+    
+    shelf_alpha_arg = DeclareLaunchArgument(
+        'alpha',
+        default_value='0.3',
+        description='Transparency level for filled shelves (0.0-1.0)'
+    )
+
+    # Static transform publisher for map frame
+    static_tf_node = Node(
+        package='tf2_ros',
+        executable='static_transform_publisher',
+        name='map_tf_publisher',
+        arguments=['0', '0', '0', '0', '0', '0', 'world', 'map'],
+        output='screen',
+    )
+    
+    # Layout visualizer node with optional filled shelves arguments
+    layout_visualizer_node = Node(
+        package='db_loader',
+        executable='layout_visualizer',
+        name='layout_visualizer',
+        output='screen',
+        arguments=[
+            '--filled',
+            '--alpha',
+            LaunchConfiguration('alpha')
+        ],
+        condition=IfCondition(
+            PythonExpression([
+                '"', LaunchConfiguration('filled'), '" == "true"'
+            ])
+        ),
+    )
+    
+    # Layout visualizer node WITHOUT filled shelves (default)
+    layout_visualizer_wireframe_node = Node(
+        package='db_loader',
+        executable='layout_visualizer',
+        name='layout_visualizer',
+        output='screen',
+        condition=IfCondition(
+            PythonExpression([
+                '"', LaunchConfiguration('filled'), '" != "true"'
+            ])
+        ),
+    )
+
+    # RViz2 (only launches if rviz_config is provided)
+    rviz_node = Node(
+        package='rviz2',
+        executable='rviz2',
+        name='rviz2',
+        output='screen',
+        arguments=['-d', LaunchConfiguration('rviz_config')],
+        condition=IfCondition(
+            PythonExpression([
+                '"', LaunchConfiguration('rviz_config'), '" != ""'
+            ])
+        ),
+    )
+
+    # Layout publisher node (DELAYED to ensure subscribers are ready)
+    layout_publisher_node = Node(
+        package='db_loader',
+        executable='layout_publisher',
+        name='layout_publisher',
+        output='screen',
+        arguments=[LaunchConfiguration('json_file')],
+        condition=IfCondition(
+            PythonExpression([
+                '"', LaunchConfiguration('json_file'), '" != ""'
+            ])
+        ),
+    )
+      
+    # Wrap layout publisher in TimerAction to delay its start
+    delayed_layout_publisher = TimerAction(
+        period=LaunchConfiguration('publisher_delay'),
+        actions=[layout_publisher_node]
+    )
+    
+    return LaunchDescription([
+        json_file_arg,
+        rviz_config_arg,
+        publisher_delay_arg,
+        filled_shelves_arg,
+        shelf_alpha_arg,
+        static_tf_node,
+        layout_visualizer_node,
+        layout_visualizer_wireframe_node,
+        rviz_node,
+        delayed_layout_publisher,
+    ])

keypoint-db/ws/src/db_loader/package.xml

@@ -0,0 +1,26 @@
+<?xml version="1.0"?>
+<?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
+<package format="3">
+  <name>db_loader</name>
+  <version>0.0.0</version>
+  <description>TODO: Package description</description>
+  <maintainer email="user@todo.todo">user</maintainer>
+  <license>TODO: License declaration</license>
+
+  <depend>rclpy</depend>
+  <depend>db_loader_msgs</depend>
+
+  <depend>std_msgs</depend>
+  <depend>visualization_msgs</depend>
+  <depend>geometry_msgs</depend>
+  <depend>tf2_ros</depend>
+
+  <test_depend>ament_copyright</test_depend>
+  <test_depend>ament_flake8</test_depend>
+  <test_depend>ament_pep257</test_depend>
+  <test_depend>python3-pytest</test_depend>
+
+  <export>
+    <build_type>ament_python</build_type>
+  </export>
+</package>

keypoint-db/ws/src/db_loader/rviz/layout_view.rviz

@@ -0,0 +1,278 @@
+Panels:
+  - Class: rviz_common/Displays
+    Help Height: 78
+    Name: Displays
+    Property Tree Widget:
+      Expanded:
+        - /Global Options1
+        - /Status1
+        - /MarkerArray1
+        - /MarkerArray1/Topic1
+        - /MarkerArray1/Namespaces1
+        - /MarkerArray2
+        - /MarkerArray2/Topic1
+        - /MarkerArray2/Namespaces1
+        - /MarkerArray3
+        - /MarkerArray3/Topic1
+        - /MarkerArray3/Namespaces1
+      Splitter Ratio: 0.5
+    Tree Height: 872
+  - Class: rviz_common/Selection
+    Name: Selection
+  - Class: rviz_common/Tool Properties
+    Expanded:
+      - /2D Goal Pose1
+      - /Publish Point1
+    Name: Tool Properties
+    Splitter Ratio: 0.5886790156364441
+  - Class: rviz_common/Views
+    Expanded:
+      - /Current View1
+      - /Current View1/Focal Point1
+    Name: Views
+    Splitter Ratio: 0.5
+  - Class: rviz_common/Time
+    Experimental: false
+    Name: Time
+    SyncMode: 0
+    SyncSource: ""
+Visualization Manager:
+  Class: ""
+  Displays:
+    - Alpha: 0.5
+      Cell Size: 1
+      Class: rviz_default_plugins/Grid
+      Color: 160; 160; 164
+      Enabled: true
+      Line Style:
+        Line Width: 0.029999999329447746
+        Value: Lines
+      Name: Grid
+      Normal Cell Count: 0
+      Offset:
+        X: 0
+        Y: 0
+        Z: 0
+      Plane: XY
+      Plane Cell Count: 10
+      Reference Frame: <Fixed Frame>
+      Value: true
+    - Class: rviz_default_plugins/MarkerArray
+      Enabled: true
+      Name: MarkerArray
+      Namespaces:
+        exits: true
+        perimeters: true
+        shelf_labels: true
+        shelf_normals: true
+        shelves_filled: true
+      Topic:
+        Depth: 5
+        Durability Policy: Volatile
+        History Policy: Keep Last
+        Reliability Policy: Reliable
+        Value: /layout_markers
+      Value: true
+    - Class: rviz_default_plugins/MarkerArray
+      Enabled: true
+      Name: MarkerArray
+      Namespaces:
+        {}
+      Topic:
+        Depth: 5
+        Durability Policy: Volatile
+        History Policy: Keep Last
+        Reliability Policy: Reliable
+        Value: /trajectory_markers
+      Value: true
+    - Class: rviz_default_plugins/MarkerArray
+      Enabled: true
+      Name: MarkerArray
+      Namespaces:
+        bones_0517f65b3c75: true
+        bones_0b07ef703ff5: true
+        bones_123f861f40f3: true
+        bones_1bbc027eefa9: true
+        bones_27f426e5a557: true
+        bones_2f4dd05a7245: true
+        bones_41a82347ec7f: true
+        bones_4c8fd32b9cb1: true
+        bones_5eb2934bdcdb: true
+        bones_608b25ee75ee: true
+        bones_6851191f2665: true
+        bones_6edab2f72299: true
+        bones_762cd03e1d6c: true
+        bones_7d5ddf3a2aee: true
+        bones_829da41cc1ff: true
+        bones_8770c5602760: true
+        bones_9c41688ab5d3: true
+        bones_9cb974ac6ef0: true
+        bones_ab00e53fc02c: true
+        bones_abe1d799c0a4: true
+        bones_b38f535c4d54: true
+        bones_bbf6931d3aed: true
+        bones_bc979d823976: true
+        bones_bde273497bef: true
+        bones_d759ac1884c2: true
+        bones_de15e3f664fe: true
+        bones_def60a8e631b: true
+        bones_e61be4b65499: true
+        bones_f4c6b95ec893: true
+        bones_f8303beacac9: true
+        bones_f8e17e4034fa: true
+        bones_fd86fa155639: true
+        keypoints_0517f65b3c75: true
+        keypoints_0b07ef703ff5: true
+        keypoints_123f861f40f3: true
+        keypoints_1bbc027eefa9: true
+        keypoints_27f426e5a557: true
+        keypoints_2f4dd05a7245: true
+        keypoints_41a82347ec7f: true
+        keypoints_4c8fd32b9cb1: true
+        keypoints_5eb2934bdcdb: true
+        keypoints_608b25ee75ee: true
+        keypoints_6851191f2665: true
+        keypoints_6edab2f72299: true
+        keypoints_762cd03e1d6c: true
+        keypoints_7d5ddf3a2aee: true
+        keypoints_829da41cc1ff: true
+        keypoints_8770c5602760: true
+        keypoints_9c41688ab5d3: true
+        keypoints_9cb974ac6ef0: true
+        keypoints_ab00e53fc02c: true
+        keypoints_abe1d799c0a4: true
+        keypoints_b38f535c4d54: true
+        keypoints_bbf6931d3aed: true
+        keypoints_bc979d823976: true
+        keypoints_bde273497bef: true
+        keypoints_d759ac1884c2: true
+        keypoints_de15e3f664fe: true
+        keypoints_def60a8e631b: true
+        keypoints_e61be4b65499: true
+        keypoints_f4c6b95ec893: true
+        keypoints_f8303beacac9: true
+        keypoints_f8e17e4034fa: true
+        keypoints_fd86fa155639: true
+        labels_0517f65b3c75: true
+        labels_0b07ef703ff5: true
+        labels_123f861f40f3: true
+        labels_1bbc027eefa9: true
+        labels_27f426e5a557: true
+        labels_2f4dd05a7245: true
+        labels_41a82347ec7f: true
+        labels_4c8fd32b9cb1: true
+        labels_5eb2934bdcdb: true
+        labels_608b25ee75ee: true
+        labels_6851191f2665: true
+        labels_6edab2f72299: true
+        labels_762cd03e1d6c: true
+        labels_7d5ddf3a2aee: true
+        labels_829da41cc1ff: true
+        labels_8770c5602760: true
+        labels_9c41688ab5d3: true
+        labels_9cb974ac6ef0: true
+        labels_ab00e53fc02c: true
+        labels_abe1d799c0a4: true
+        labels_b38f535c4d54: true
+        labels_bbf6931d3aed: true
+        labels_bc979d823976: true
+        labels_bde273497bef: true
+        labels_d759ac1884c2: true
+        labels_de15e3f664fe: true
+        labels_def60a8e631b: true
+        labels_e61be4b65499: true
+        labels_f4c6b95ec893: true
+        labels_f8303beacac9: true
+        labels_f8e17e4034fa: true
+        labels_fd86fa155639: true
+      Topic:
+        Depth: 1
+        Durability Policy: Volatile
+        History Policy: Keep Last
+        Reliability Policy: Reliable
+        Value: /skeleton_markers
+      Value: true
+  Enabled: true
+  Global Options:
+    Background Color: 207; 207; 207
+    Fixed Frame: map
+    Frame Rate: 30
+  Name: root
+  Tools:
+    - Class: rviz_default_plugins/Interact
+      Hide Inactive Objects: true
+    - Class: rviz_default_plugins/MoveCamera
+    - Class: rviz_default_plugins/Select
+    - Class: rviz_default_plugins/FocusCamera
+    - Class: rviz_default_plugins/Measure
+      Line color: 128; 128; 0
+    - Class: rviz_default_plugins/SetInitialPose
+      Covariance x: 0.25
+      Covariance y: 0.25
+      Covariance yaw: 0.06853891909122467
+      Topic:
+        Depth: 5
+        Durability Policy: Volatile
+        History Policy: Keep Last
+        Reliability Policy: Reliable
+        Value: /initialpose
+    - Class: rviz_default_plugins/SetGoal
+      Topic:
+        Depth: 5
+        Durability Policy: Volatile
+        History Policy: Keep Last
+        Reliability Policy: Reliable
+        Value: /goal_pose
+    - Class: rviz_default_plugins/PublishPoint
+      Single click: true
+      Topic:
+        Depth: 5
+        Durability Policy: Volatile
+        History Policy: Keep Last
+        Reliability Policy: Reliable
+        Value: /clicked_point
+  Transformation:
+    Current:
+      Class: rviz_default_plugins/TF
+  Value: true
+  Views:
+    Current:
+      Class: rviz_default_plugins/XYOrbit
+      Distance: 13.364635467529297
+      Enable Stereo Rendering:
+        Stereo Eye Separation: 0.05999999865889549
+        Stereo Focal Distance: 1
+        Swap Stereo Eyes: false
+        Value: false
+      Focal Point:
+        X: 5.0003252029418945
+        Y: 2.261509895324707
+        Z: 1.430511474609375e-05
+      Focal Shape Fixed Size: false
+      Focal Shape Size: 0.05000000074505806
+      Invert Z Axis: false
+      Name: Current View
+      Near Clip Distance: 0.009999999776482582
+      Pitch: 1.1153980493545532
+      Target Frame: map
+      Value: XYOrbit (rviz_default_plugins)
+      Yaw: 4.698578834533691
+    Saved: ~
+Window Geometry:
+  Displays:
+    collapsed: true
+  Height: 1163
+  Hide Left Dock: true
+  Hide Right Dock: true
+  QMainWindow State: 000000ff00000000fd000000040000000000000156000003f1fc0200000008fb0000001200530065006c0065006300740069006f006e00000001e10000009b0000005c00fffffffb0000001e0054006f006f006c002000500072006f007000650072007400690065007302000001ed000001df00000185000000a3fb000000120056006900650077007300200054006f006f02000001df000002110000018500000122fb000000200054006f006f006c002000500072006f0070006500720074006900650073003203000002880000011d000002210000017afb000000100044006900730070006c006100790073000000003b000003f1000000c700fffffffb0000002000730065006c0065006300740069006f006e00200062007500660066006500720200000138000000aa0000023a00000294fb00000014005700690064006500530074006500720065006f02000000e6000000d2000003ee0000030bfb0000000c004b0069006e0065006300740200000186000001060000030c00000261000000010000010f000003f1fc0200000003fb0000001e0054006f006f006c002000500072006f00700065007200740069006500730100000041000000780000000000000000fb0000000a00560069006500770073000000003b000003f1000000a000fffffffb0000001200530065006c0065006300740069006f006e010000025a000000b200000000000000000000000200000490000000a9fc0100000001fb0000000a00560069006500770073030000004e00000080000002e10000019700000003000007800000003efc0100000002fb0000000800540069006d00650100000000000007800000025300fffffffb0000000800540069006d0065010000000000000450000000000000000000000780000003f100000004000000040000000800000008fc0000000100000002000000010000000a0054006f006f006c00730100000000ffffffff0000000000000000
+  Selection:
+    collapsed: false
+  Time:
+    collapsed: false
+  Tool Properties:
+    collapsed: false
+  Views:
+    collapsed: true
+  Width: 1920
+  X: 3840
+  Y: 0

keypoint-db/ws/src/db_loader/rviz/layout_view_rviz

@@ -0,0 +1,133 @@
+Panels:
+  - Class: rviz_common/Displays
+    Help Height: 78
+    Name: Displays
+    Property Tree Widget:
+      Expanded:
+        - /Global Options1
+        - /Status1
+        - /Layout Markers1
+        - /MarkerArray1
+      Splitter Ratio: 0.5
+    Tree Height: 1308
+  - Class: rviz_common/Views
+    Expanded:
+      - /Current View1
+    Name: Views
+    Splitter Ratio: 0.5
+Visualization Manager:
+  Class: ""
+  Displays:
+    - Alpha: 0.5
+      Cell Size: 1
+      Class: rviz_default_plugins/Grid
+      Color: 160; 160; 164
+      Enabled: true
+      Line Style:
+        Line Width: 0.029999999329447746
+        Value: Lines
+      Name: Grid
+      Normal Cell Count: 0
+      Offset:
+        X: 0
+        Y: 0
+        Z: 0
+      Plane: XY
+      Plane Cell Count: 50
+      Reference Frame: <Fixed Frame>
+      Value: true
+    - Class: rviz_default_plugins/MarkerArray
+      Enabled: true
+      Name: Layout Markers
+      Namespaces:
+        exits: true
+        perimeters: true
+        shelf_labels: true
+        shelf_normals: true
+        shelves: true
+      Topic:
+        Depth: 5
+        Durability Policy: Volatile
+        History Policy: Keep Last
+        Reliability Policy: Reliable
+        Value: /layout_markers
+      Value: true
+    - Class: rviz_default_plugins/MarkerArray
+      Enabled: true
+      Name: MarkerArray
+      Namespaces:
+        exits: true
+        perimeters: true
+        shelf_labels: true
+        shelf_normals: true
+        shelves: true
+      Topic:
+        Depth: 5
+        Durability Policy: Volatile
+        History Policy: Keep Last
+        Reliability Policy: Reliable
+        Value: /layout_markers
+      Value: true
+  Enabled: true
+  Global Options:
+    Background Color: 162; 162; 162
+    Fixed Frame: map
+    Frame Rate: 30
+  Name: root
+  Tools:
+    - Class: rviz_default_plugins/MoveCamera
+    - Class: rviz_default_plugins/Select
+    - Class: rviz_default_plugins/FocusCamera
+    - Class: rviz_default_plugins/Measure
+      Line color: 128; 128; 0
+  Transformation:
+    Current:
+      Class: rviz_default_plugins/TF
+  Value: true
+  Views:
+    Current:
+      Angle: 0.039999958127737045
+      Class: rviz_default_plugins/TopDownOrtho
+      Enable Stereo Rendering:
+        Stereo Eye Separation: 0.05999999865889549
+        Stereo Focal Distance: 1
+        Swap Stereo Eyes: false
+        Value: false
+      Invert Z Axis: false
+      Name: Current View
+      Near Clip Distance: 0.009999999776482582
+      Scale: 119.80030059814453
+      Target Frame: <Fixed Frame>
+      Value: TopDownOrtho (rviz_default_plugins)
+      X: 5.269617557525635
+      Y: 4.5275774002075195
+    Saved: ~
+Window Geometry:
+  Displays:
+    collapsed: false
+  Height: 1531
+  Hide Left Dock: false
+  Hide Right Dock: false
+  QMainWindow State: 000000ff00000000fd000000040000000000000156000005a5fc0200000008fb0000001200530065006c0065006300740069006f006e00000001e10000009b0000000000000000fb0000001e0054006f006f006c002000500072006f007000650072007400690065007302000001ed000001df00000185000000a3fb000000120056006900650077007300200054006f006f02000001df000002110000018500000122fb000000200054006f006f006c002000500072006f0070006500720074006900650073003203000002880000011d000002210000017afb000000100044006900730070006c006100790073010000003b000005a5000000c700fffffffb0000002000730065006c0065006300740069006f006e00200062007500660066006500720200000138000000aa0000023a00000294fb00000014005700690064006500530074006500720065006f02000000e6000000d2000003ee0000030bfb0000000c004b0069006e0065006300740200000186000001060000030c00000261000000010000010f000005a5fc0200000003fb0000001e0054006f006f006c002000500072006f00700065007200740069006500730100000041000000780000000000000000fb0000000a00560069006500770073010000003b000005a5000000a000fffffffb0000001200530065006c0065006300740069006f006e010000025a000000b200000000000000000000000200000490000000a9fc0100000001fb0000000a00560069006500770073030000004e00000080000002e10000019700000003000004b00000003efc0100000002fb0000000800540069006d00650100000000000004b00000000000000000fb0000000800540069006d006501000000000000045000000000000000000000074d000005a500000004000000040000000800000008fc0000000100000002000000010000000a0054006f006f006c00730100000000ffffffff0000000000000000
+  Views:
+    collapsed: false
+  Width: 2494
+  X: 66
+  Y: 32
+
+
+
+
+
+    - Class: rviz_default_plugins/MarkerArray
+      Enabled: true
+      Name: Trajectory Markers
+      Namespaces:
+        {}
+      Topic:
+        Depth: 5
+        Durability Policy: Volatile
+        History Policy: Keep Last
+        Reliability Policy: Reliable
+        Value: /trajectory_markers
+      Value: true

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

@@ -0,0 +1,4 @@
+[develop]
+script_dir=$base/lib/db_loader
+[install]
+install_scripts=$base/lib/db_loader

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

@@ -0,0 +1,40 @@
+import os
+from glob import glob
+from setuptools import find_packages, setup
+
+package_name = 'db_loader'
+
+setup(
+    name=package_name,
+    version='0.0.0',
+    packages=find_packages(exclude=['test']),
+    data_files=[
+        ('share/ament_index/resource_index/packages',
+            ['resource/' + package_name]),
+        ('share/' + package_name, ['package.xml']),
+        (os.path.join('share', package_name, 'launch'), glob('launch/*.py')),
+        (os.path.join('share', package_name, 'rviz'), glob('rviz/*.rviz')),
+
+
+
+    ],
+    install_requires=['setuptools'],
+    zip_safe=True,
+    maintainer='user',
+    maintainer_email='user@todo.todo',
+    description='TODO: Package description',
+    license='TODO: License declaration',
+    extras_require={
+        'test': [
+            'pytest',
+        ],
+    },
+    entry_points={
+        'console_scripts': [
+            'layout_publisher = db_loader.layout_publisher:main',
+            'layout_visualizer = db_loader.layout_visualizer:main',
+            'keypoint_publisher = db_loader.keypoint_publisher:main',
+            'index_keypoint_publisher = db_loader.index_keypoint_publisher:main',
+        ],
+    },
+)

keypoint-db/ws/src/db_loader/test/test_copyright.py

@@ -0,0 +1,25 @@
+# Copyright 2015 Open Source Robotics Foundation, Inc.
+#
+# 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 ament_copyright.main import main
+import pytest
+
+
+# Remove the `skip` decorator once the source file(s) have a copyright header
+@pytest.mark.skip(reason='No copyright header has been placed in the generated source file.')
+@pytest.mark.copyright
+@pytest.mark.linter
+def test_copyright():
+    rc = main(argv=['.', 'test'])
+    assert rc == 0, 'Found errors'

keypoint-db/ws/src/db_loader/test/test_flake8.py

@@ -0,0 +1,25 @@
+# Copyright 2017 Open Source Robotics Foundation, Inc.
+#
+# 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 ament_flake8.main import main_with_errors
+import pytest
+
+
+@pytest.mark.flake8
+@pytest.mark.linter
+def test_flake8():
+    rc, errors = main_with_errors(argv=[])
+    assert rc == 0, \
+        'Found %d code style errors / warnings:\n' % len(errors) + \
+        '\n'.join(errors)

keypoint-db/ws/src/db_loader/test/test_pep257.py

@@ -0,0 +1,23 @@
+# Copyright 2015 Open Source Robotics Foundation, Inc.
+#
+# 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 ament_pep257.main import main
+import pytest
+
+
+@pytest.mark.linter
+@pytest.mark.pep257
+def test_pep257():
+    rc = main(argv=['.', 'test'])
+    assert rc == 0, 'Found code style errors / warnings'

keypoint-db/ws/src/db_loader_msgs/CMakeLists.txt

@@ -0,0 +1,21 @@
+cmake_minimum_required(VERSION 3.8)
+project(db_loader_msgs)
+
+if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+  add_compile_options(-Wall -Wextra -Wpedantic)
+endif()
+
+# find dependencies
+find_package(ament_cmake REQUIRED)
+find_package(rosidl_default_generators REQUIRED)
+find_package(std_msgs REQUIRED)
+
+# Generate interfaces
+rosidl_generate_interfaces(${PROJECT_NAME}
+  "msg/Skeleton.msg"
+  DEPENDENCIES std_msgs
+)
+
+ament_export_dependencies(rosidl_default_runtime)
+
+ament_package()

keypoint-db/ws/src/db_loader_msgs/msg/Skeleton.msg

@@ -0,0 +1,74 @@
+# Skeleton keypoints for a single person
+string person_track_id
+float64 timestamp
+
+# Head
+float64 top_of_head_x
+float64 top_of_head_y
+float64 top_of_head_z
+
+# Neck
+float64 neck_x
+float64 neck_y
+float64 neck_z
+
+# Right arm
+float64 right_shoulder_x
+float64 right_shoulder_y
+float64 right_shoulder_z
+float64 right_elbow_x
+float64 right_elbow_y
+float64 right_elbow_z
+float64 right_wrist_x
+float64 right_wrist_y
+float64 right_wrist_z
+float64 right_hand_x
+float64 right_hand_y
+float64 right_hand_z
+
+# Left arm
+float64 left_shoulder_x
+float64 left_shoulder_y
+float64 left_shoulder_z
+float64 left_elbow_x
+float64 left_elbow_y
+float64 left_elbow_z
+float64 left_wrist_x
+float64 left_wrist_y
+float64 left_wrist_z
+float64 left_hand_x
+float64 left_hand_y
+float64 left_hand_z
+
+# Waist
+float64 middle_of_waist_x
+float64 middle_of_waist_y
+float64 middle_of_waist_z
+
+# Right leg
+float64 right_hip_x
+float64 right_hip_y
+float64 right_hip_z
+float64 right_knee_x
+float64 right_knee_y
+float64 right_knee_z
+float64 right_ankle_x
+float64 right_ankle_y
+float64 right_ankle_z
+float64 right_foot_x
+float64 right_foot_y
+float64 right_foot_z
+
+# Left leg
+float64 left_hip_x
+float64 left_hip_y
+float64 left_hip_z
+float64 left_knee_x
+float64 left_knee_y
+float64 left_knee_z
+float64 left_ankle_x
+float64 left_ankle_y
+float64 left_ankle_z
+float64 left_foot_x
+float64 left_foot_y
+float64 left_foot_z

keypoint-db/ws/src/db_loader_msgs/package.xml

@@ -0,0 +1,24 @@
+<?xml version="1.0"?>
+<?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
+<package format="3">
+  <name>db_loader_msgs</name>
+  <version>0.0.0</version>
+  <description>Custom messages for db_loader package</description>
+  <maintainer email="user@todo.todo">user</maintainer>
+  <license>MIT</license>
+
+  <buildtool_depend>ament_cmake</buildtool_depend>
+
+  <depend>std_msgs</depend>
+  
+  <build_depend>rosidl_default_generators</build_depend>
+  <exec_depend>rosidl_default_runtime</exec_depend>
+  <member_of_group>rosidl_interface_packages</member_of_group>
+
+  <test_depend>ament_lint_auto</test_depend>
+  <test_depend>ament_lint_common</test_depend>
+
+  <export>
+    <build_type>ament_cmake</build_type>
+  </export>
+</package>