Datasets:

yyyyyt
/

pick_object

@@ -1,165 +0,0 @@
-import h5py
-import cv2
-import numpy as np
-import argparse
-import csv
-import json
-from pathlib import Path
-import shutil
-def load_robot_data(csv_path):
-    """
-    Returns: master_ts, robot_ts, qpos, gripper
-    """
-    master_timestamps = []
-    robot_timestamps = []
-    qpos = []
-    gripper = []
-    with open(csv_path, 'r') as f:
-        reader = csv.reader(f)
-        try:
-            header = next(reader)
-            # Check format
-            # Format 1: master_timestamp, robot_timestamp, j0..j5, gripper
-            # Format 2: cam_timestamp, robot_timestamp, j0..j5, gripper (Previous version)
-            # Format 3: timestamp, j0..j5, gripper (Legacy)
-            if header[0] == 'master_timestamp' or header[0] == 'cam_timestamp':
-                # New formats
-                for row in reader:
-                    master_timestamps.append(float(row[0]))
-                    robot_timestamps.append(float(row[1]))
-                    qpos.append([float(x) for x in row[2:8]])
-                    gripper.append(float(row[8]))
-            else:
-                # Legacy format
-                for row in reader:
-                    t = float(row[0])
-                    master_timestamps.append(t)
-                    robot_timestamps.append(t)
-                    qpos.append([float(x) for x in row[1:7]])
-                    gripper.append(float(row[7]))
-        except StopIteration:
-            return np.array([]), np.array([]), np.array([]), np.array([])
-    return np.array(master_timestamps), np.array(robot_timestamps), np.array(qpos), np.array(gripper)
-def process_episode(episode_path, output_path):
-    print(f"Processing {episode_path}...")
-    csv_path = episode_path / "robot_data.csv"
-    if not csv_path.exists():
-        print(f"Skipping {episode_path}: Missing CSV")
-        return
-    # Load Robot Data
-    master_ts, robot_ts, qpos, gripper = load_robot_data(csv_path)
-    if len(master_ts) == 0:
-        print(f"Skipping {episode_path}: Empty CSV")
-        return
-    num_frames = len(master_ts)
-    # Find all camera directories
-    cam_dirs = sorted(list(episode_path.glob("cam_*")))
-    if not cam_dirs:
-        print(f"Skipping {episode_path}: No camera directories found")
-        return
-    # Prepare HDF5 file
-    with h5py.File(output_path, 'w') as root:
-        root.attrs['sim'] = False
-        obs = root.create_group('observations')
-        # Robot State
-        obs.create_dataset('qpos', data=qpos)
-        obs.create_dataset('qvel', data=np.zeros_like(qpos)) # Placeholder, see below
-        # Process Images
-        min_frames = num_frames
-        for cam_dir in cam_dirs:
-            cam_name = cam_dir.name # e.g. cam_head
-            image_files = sorted(list(cam_dir.glob("*.jpg")), key=lambda x: int(x.stem))
-            # Check count
-            if len(image_files) != num_frames:
-                print(f"Warning: {cam_name} frames ({len(image_files)}) != CSV rows ({num_frames}). Truncating.")
-                min_frames = min(min_frames, len(image_files))
-            # Load images
-            # Note: Loading all to memory might be heavy for many cameras/long episodes
-            # Consider chunking if needed. For now, simple load.
-            images = []
-            for img_path in image_files[:min_frames]:
-                img = cv2.imread(str(img_path))
-                images.append(img)
-            images = np.array(images)
-            obs.create_dataset(f'images/{cam_name}', data=images)
-        # Truncate robot data if images were shorter
-        if min_frames < num_frames:
-            qpos = qpos[:min_frames]
-            gripper = gripper[:min_frames]
-            robot_ts = robot_ts[:min_frames]
-            master_ts = master_ts[:min_frames]
-            # Re-save truncated qpos
-            del obs['qpos']
-            obs.create_dataset('qpos', data=qpos)
-        # Compute qvel
-        qvel = np.zeros_like(qpos)
-        if len(qpos) > 1:
-            dt = np.diff(robot_ts)
-            dt = np.where(dt == 0, 1e-3, dt)[:, None]
-            qvel[:-1] = (qpos[1:] - qpos[:-1]) / dt
-            qvel[-1] = qvel[-2]
-        del obs['qvel']
-        obs.create_dataset('qvel', data=qvel)
-        # Action
-        action = np.zeros_like(qpos)
-        action[:-1] = qpos[1:]
-        action[-1] = qpos[-1]
-        root.create_dataset('action', data=action)
-        # Store timestamps
-        # obs.create_dataset('timestamp', data=master_ts)
-    print(f"Saved to {output_path}")
-def main():
-    parser = argparse.ArgumentParser(description="Convert raw data to HDF5 for ACT")
-    parser.add_argument('--task', required=True, help="Task name")
-    parser.add_argument('--out', default="dataset.hdf5", help="Output HDF5 filename (or dir)")
-    args = parser.parse_args()
-    data_root = Path("data")
-    task_dir = data_root / args.task
-    if not task_dir.exists():
-        print(f"Task {args.task} not found in {data_root}")
-        return
-    episodes = sorted(list(task_dir.glob("episode_*")))
-    output_dir = Path(args.out)
-    output_dir.mkdir(exist_ok=True, parents=True)
-    for ep_dir in episodes:
-        out_name = f"{ep_dir.name}.hdf5"
-        process_episode(ep_dir, output_dir / out_name)
-if __name__ == "__main__":
-    main()