UPDATE: new bouncing ball dataset

README.md

@@ -113,6 +113,10 @@ python /home/lau/sim/DynaTraj/sb3_collect.py \
   --render
 ```
 
+For Bouncing ball:
+python bb_collect.py --trajectories 1024 --steps_per_trajectory 8192
+
+
 Notes:
 - The script searches checkpoints under `ckpt_root/<domain>/<task>/` as `ckpt-<k>.pt`. If you see an error for `ckpt-0.pt`, switch to 1-based indices.
 - If your environment has no display backend, simply omit `--render`.

bb_collect.py

@@ -3,8 +3,14 @@ import numpy as np
 import argparse
 from typing import Optional, Tuple, Dict, Any
 import time
+import os
+from datetime import datetime
 from dataclasses import dataclass
 from scipy.spatial.transform import Rotation as R
+from tqdm import tqdm
+import pickle
+
+from dataset import TrajectoryBuffer
 
 
 @dataclass
@@ -288,8 +294,8 @@ class PingPongEnv:
         obs = np.concatenate([global_obs, local_obs])  # Total: 33 dimensions
 
         # Done condition: ball(x,y) out of [100,100] or z lower than board - 0.1m
-        done = (abs(ball_pos[0]) > 10.0 or 
-                abs(ball_pos[1]) > 10.0 or 
+        done = (abs(ball_pos[0]) > 100.0 or 
+                abs(ball_pos[1]) > 100.0 or 
                 ball_pos[2] < (board_pos[2] - 0.1))
         
         return obs, done
@@ -357,6 +363,15 @@ class PingPongDummyController:
         self.target_yaw = 0.0
         self.last_update_time = 0.0
     
+    def reset_controller(self):
+        """Reset controller state for new episode"""
+        self.last_update_time = 0.0
+        # Optionally reset targets to initial values
+        self.target_z = 0.5
+        self.target_roll = 0.0
+        self.target_pitch = 0.0
+        self.target_yaw = 0.0
+    
     def quat_to_euler(self, quat: np.ndarray) -> np.ndarray:
         """
         Convert quaternion to Euler angles (roll, pitch, yaw).
@@ -543,46 +558,202 @@ class PingPongDummyController:
         return action
 
 
-def main():
-    parser = argparse.ArgumentParser(description="Ping Pong MuJoCo Environment")
-    parser.add_argument('--headless', action='store_true', help='Run in headless mode for video recording')
-    parser.add_argument('--steps', type=int, default=1000, help='Number of simulation steps')
-    parser.add_argument('--realtime', action='store_true', help='Match simulation speed to real time')
-    parser.add_argument('--use-controller', action='store_true', help='Use PingPongDummyController to stabilize board')
-    args = parser.parse_args()
+def collect_bouncing_ball_data(
+    env: PingPongEnv,
+    controller: PingPongDummyController,
+    target_trajectories: int,
+    steps_per_traj: int,
+    render: bool = False,
+    realtime: bool = False
+) -> TrajectoryBuffer:
+    """
+    Collect trajectory data from bouncing ball environment using ball_response controller.
+    
+    Args:
+        env: PingPong environment
+        controller: Controller for board movement
+        target_trajectories: Number of trajectories to collect
+        steps_per_traj: Steps per trajectory
+        render: Whether to render during collection
+        realtime: Whether to match simulation speed to real time
+        
+    Returns:
+        TrajectoryBuffer with collected data
+    """
+    buffer = TrajectoryBuffer(steps_per_traj)
     
-    # Create configuration and environment
-    config = Config()
-    env = PingPongEnv(headless=args.headless, config=config)
+    pbar = tqdm(total=target_trajectories, desc="Collecting bouncing ball data")
     
-    # Create controller if requested
-    controller = PingPongDummyController(config=config) if args.use_controller else None
+    collected_trajs = 0
     
-    try:
-        # Reset environment
+    while collected_trajs < target_trajectories:
+        # Reset environment and controller
         obs = env.reset()
-        print(f"Initial observation: {obs}")
+        controller.reset_controller()
         
-        # Run simulation
-        for step in range(args.steps):
-            # Get action from controller or use None for free simulation
-            # action = controller.get_dummy_position_action(env) if controller else None
-            action = controller.get_ball_response_action(env) if controller else None
+        # Collect one trajectory
+        for step in range(steps_per_traj):
+            # Get current observation and done flag
+            current_obs, done = env.get_obs()
+            
+            # Get action from ball_response controller
+            action = controller.get_ball_response_action(env)
+            
+            # Calculate reward (simple distance-based for now)
+            ball_qpos_idx = env.model.jnt_qposadr[mujoco.mj_name2id(env.model, mujoco.mjtObj.mjOBJ_JOINT, "ball_free")]
+            board_qpos_idx = env.model.jnt_qposadr[mujoco.mj_name2id(env.model, mujoco.mjtObj.mjOBJ_JOINT, "board_free")]
+            ball_pos = env.data.qpos[ball_qpos_idx:ball_qpos_idx+3]
+            board_pos = env.data.qpos[board_qpos_idx:board_qpos_idx+3]
+            
+            # Reward based on ball-board distance (encouraging ball to stay near board)
+            distance = np.linalg.norm(ball_pos[:2] - board_pos[:2])  # x,y distance only
+            reward = -distance  # Negative distance as reward
+            
+            # Step environment first to get the next state
+            _, _, env_done, _ = env.step(action)
             
-            obs, reward, done, info = env.step(action)
+            # Get done status after stepping (this is what we want to predict)
+            _, done_after_step = env.get_obs()
             
-            if not args.headless:
-                # Render every frame for smooth visualization
+            # Append step to buffer (B=1 for single environment)
+            # obs->action->done pattern: observation leads to action, done is result after action
+            obs_np = current_obs[None, :]  # Add batch dimension
+            ext_obs_np = obs_np  # Same as obs for this environment
+            action_np = action[None, :]  # Add batch dimension
+            reward_np = np.array([reward], dtype=np.float32)
+            done_np = np.array([done_after_step], dtype=np.bool_)  # Done status after applying action
+            
+            buffer.append_step(obs_np, ext_obs_np, action_np, reward_np, done_np)
+            
+            # Render if requested
+            if render:
                 env.render()
-            if args.realtime:
+            
+            # Sleep for realtime if requested
+            if realtime:
                 time.sleep(env.model.opt.timestep)
-            if done:
+            
+            # Break if episode is done
+            if done_after_step or env_done:
                 break
         
-        print("Simulation completed")
-        
-    finally:
-        env.close()
+        collected_trajs += 1
+        pbar.update(1)
+    
+    pbar.close()
+    return buffer
+
+
+def parse_data_collection_args():
+    """Parse command line arguments for data collection"""
+    parser = argparse.ArgumentParser(description="Collect bouncing ball dataset")
+    parser.add_argument("--trajectories", type=int, default=1000, help="Number of trajectories to collect")
+    parser.add_argument("--steps_per_trajectory", type=int, default=20000, help="Steps per trajectory")
+    parser.add_argument("--out_dir", type=str, default="./dataset/bb/", help="Output directory")
+    parser.add_argument("--seed", type=int, default=42, help="Random seed")
+    parser.add_argument("--headless", action="store_true", help="Run in headless mode (no rendering)")
+    
+    # Demo simulation args for backward compatibility
+    parser.add_argument("--realtime", action="store_true", help="Match simulation speed to real time")
+    parser.add_argument("--demo", action="store_true", help="Run demo mode instead of data collection")
+    
+    return parser.parse_args()
+
+
+def main():
+    args = parse_data_collection_args()
+    
+    # Set random seed
+    np.random.seed(args.seed)
+    
+    if args.demo:
+        # Demo simulation mode
+        # Create configuration and environment
+        config = Config()
+        env = PingPongEnv(headless=args.headless, config=config)
+        controller = PingPongDummyController(config=config)
+        
+        try:
+            # Reset environment and controller
+            obs = env.reset()
+            controller.reset_controller()
+            print(f"Initial observation shape: {obs.shape}")
+            
+            # Run simulation for 1000 steps
+            for step in range(1000):
+                # Get action from ball_response controller
+                action = controller.get_ball_response_action(env)
+                
+                obs, reward, done, info = env.step(action)
+                
+                if not args.headless:
+                    # Render every frame for smooth visualization
+                    env.render()
+                if args.realtime:
+                    time.sleep(env.model.opt.timestep)
+                if done:
+                    obs = env.reset()  # Auto-reset if done
+                    controller.reset_controller()  # Reset controller state
+            
+            print("Demo simulation completed")
+            
+        finally:
+            env.close()
+    
+    else:
+        # Data collection mode (default)
+        print(f"Starting data collection with {args.trajectories} trajectories...")
+        
+        # Create output directory
+        os.makedirs(args.out_dir, exist_ok=True)
+        
+        # Create configuration and environment
+        config = Config()
+        env = PingPongEnv(headless=args.headless, config=config)
+        controller = PingPongDummyController(config=config)
+        
+        try:
+            # Collect data
+            buffer = collect_bouncing_ball_data(
+                env=env,
+                controller=controller,
+                target_trajectories=args.trajectories,
+                steps_per_traj=args.steps_per_trajectory,
+                render=not args.headless,  # Render if not headless
+                realtime=args.realtime
+            )
+            
+            # Save dataset
+            timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+            file_stem = f"bb_ball_response_{timestamp}"
+            dataset_path = os.path.join(args.out_dir, f"{file_stem}.npz")
+            buffer.save(dataset_path)
+            
+            # Save metadata
+            meta = {
+                "environment": "bouncing_ball",
+                "control_mode": "ball_response",
+                "trajectories": args.trajectories,
+                "steps_per_trajectory": args.steps_per_trajectory,
+                "total_trajectories": len(buffer),
+                "total_steps": len(buffer) * args.steps_per_trajectory,
+                "seed": args.seed,
+                "config": config,
+                "timestamp": timestamp,
+                "headless": args.headless
+            }
+            
+            metadata_path = os.path.join(args.out_dir, f"{file_stem}_metadata.pkl")
+            with open(metadata_path, "wb") as f:
+                pickle.dump(meta, f)
+            
+            print(f"[INFO] Data collection completed!")
+            print(f"[INFO] Dataset saved: {dataset_path}")
+            print(f"[INFO] Metadata saved: {metadata_path}")
+            print(f"[INFO] Collected {len(buffer)} trajectories")
+            
+        finally:
+            env.close()
 
 
 if __name__ == "__main__":

dataset/bb/bb_ball_response_2025-09-19_15-43-14.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ab7afe6b73f56bf76eda4e5bdf73cb7aff3654e13403df3c530858debf54ab11
+size 2820321076

dataset/bb/bb_ball_response_2025-09-19_15-43-14_metadata.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:80bb8de135d7e54e43c989d37b8218b291fd9fd513b6ecd2362a3540d8b4ffb6
+size 781