Datasets:

zhicao
/

openpi

#!/usr/bin/env python3
"""
Process a specific chunk of DROID episodes.
Reads chunk file with episode indices and processes only those episodes.
"""

import json
from pathlib import Path
import tensorflow_datasets as tfds
from tqdm import tqdm
import torch
import numpy as np
import cv2
from droid.calibration.calibration_loader import CalibrationLoader
from droid.misc.projector import Projector

# Import preprocessing functions from the main script
import sys
sys.path.insert(0, str(Path(__file__).parent))

# Copy necessary functions
def find_closest_calibration(episode, uuid_list):
    """Find closest calibration UUID by timestamp."""
    ts = float(episode['episode_metadata']['recording_timestamp'].numpy())
    closest_uuid = None
    min_diff = float('inf')
    for uuid, calib_ts in uuid_list:
        diff = abs(ts - calib_ts)
        if diff < min_diff:
            min_diff = diff
            closest_uuid = uuid
    return closest_uuid

def sample_arm_shaped_points(mesh_2d_visible, img_h, img_w, num_points=993, seed=0):
    """Sample points in arm-shaped region excluding mesh vertices."""
    np.random.seed(seed)
    u_coords = []
    v_coords = []

    mesh_u = mesh_2d_visible[:, 0]
    mesh_v = mesh_2d_visible[:, 1]

    u_min = max(0, int(mesh_u.min()) - 50)
    u_max = min(img_w, int(mesh_u.max()) + 50)
    v_min = max(0, int(mesh_v.min()) - 50)
    v_max = min(img_h, int(mesh_v.max()) + 50)

    attempts = 0
    max_attempts = num_points * 100

    while len(u_coords) < num_points and attempts < max_attempts:
        u = np.random.randint(u_min, u_max)
        v = np.random.randint(v_min, v_max)

        # Check distance from mesh vertices
        dists = np.sqrt((mesh_u - u)**2 + (mesh_v - v)**2)
        if dists.min() > 10:
            u_coords.append(u)
            v_coords.append(v)

        attempts += 1

    if len(u_coords) < num_points:
        remaining = num_points - len(u_coords)
        u_coords.extend([img_w // 2] * remaining)
        v_coords.extend([img_h // 2] * remaining)

    return np.array(u_coords), np.array(v_coords)

def sample_wrist_points(img_h, img_w, num_sparse=300, num_dense=700, seed=0):
    """Sample wrist camera points with dense sampling in bottom region."""
    np.random.seed(seed)

    # Sparse uniform sampling
    u_sparse = np.random.randint(0, img_w, num_sparse)
    v_sparse = np.random.randint(0, img_h, num_sparse)

    # Dense sampling in bottom 60%-100%
    v_min_dense = int(img_h * 0.6)
    u_dense = np.random.randint(0, img_w, num_dense)
    v_dense = np.random.randint(v_min_dense, img_h, num_dense)

    u_all = np.concatenate([u_sparse, u_dense])
    v_all = np.concatenate([v_sparse, v_dense])

    return u_all, v_all

def load_cotracker():
    """Load CoTracker v3 offline model."""
    from cotracker.predictor import CoTrackerPredictor
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

    cotracker_paths = [
        '/mnt/kevin/vlm_models/cotracker/scaled_offline.pth',
        '/mnt/kevin/vlm_models/hub/checkpoints/scaled_offline.pth',
        '/root/workspace/code/wmrl/Dual-Dynamics-Models/DROID-main/co-tracker/checkpoints/scaled_offline.pth',
    ]

    cotracker_checkpoint = None
    for path in cotracker_paths:
        if Path(path).exists():
            cotracker_checkpoint = path
            print(f"Found CoTracker checkpoint: {cotracker_checkpoint}")
            break

    if cotracker_checkpoint is None:
        raise FileNotFoundError(f"CoTracker checkpoint not found. Tried:\n" + "\n".join(cotracker_paths))

    cotracker = CoTrackerPredictor(checkpoint=cotracker_checkpoint)
    cotracker = cotracker.to(device)
    cotracker.eval()
    return cotracker, device

def process_episode(episode, episode_idx, uuid, calib_loader, projector, cotracker, device,
                    max_frames=400, save_preview=False, output_dir=None):
    """Process a single episode."""

    # ... [Copy full function from preprocess_droid_rlds_final.py]
    # I'll use the existing implementation
    from preprocess_droid_rlds_final import process_episode as original_process_episode
    return original_process_episode(
        episode, episode_idx, uuid, calib_loader, projector, cotracker, device,
        max_frames, save_preview, output_dir
    )

def main():
    import argparse
    parser = argparse.ArgumentParser()
    parser.add_argument('--chunk-file', type=str, required=True,
                        help='Chunk JSON file with episode indices to process')
    parser.add_argument('--output-dir', type=str, default='/mnt/kevin/data/droid_processed_1000pts',
                        help='Output directory')
    parser.add_argument('--max-frames', type=int, default=400,
                        help='Max frames per episode')
    parser.add_argument('--save-previews', type=int, default=3,
                        help='Number of preview videos to save')
    parser.add_argument('--chunk-id', type=int, default=None,
                        help='Chunk ID for logging')
    args = parser.parse_args()

    # Load chunk data
    with open(args.chunk_file) as f:
        chunk_data = json.load(f)

    chunk_id = chunk_data['chunk_id'] if args.chunk_id is None else args.chunk_id
    episode_indices_set = set(chunk_data['episode_indices'])

    label = f"Chunk {chunk_id}"

    print("="*80)
    print(f"DROID Preprocessing: {label}")
    print("="*80)
    print(f"  Chunk file: {args.chunk_file}")
    print(f"  Episodes to process: {len(episode_indices_set)}")
    print(f"  Output: {args.output_dir}")
    print("="*80)

    # Setup output directories
    output_dir = Path(args.output_dir)
    data_dir = output_dir / 'data'
    preview_dir = output_dir / 'preview_videos'
    data_dir.mkdir(parents=True, exist_ok=True)
    preview_dir.mkdir(parents=True, exist_ok=True)

    # Load CoTracker
    cotracker, device = load_cotracker()

    # Load camera calibrations
    calib_loader = CalibrationLoader()
    uuid_list = [(uuid, calib_loader.get_timestamp(uuid))
                 for uuid in calib_loader.list_calibrations()]
    print(f"Loaded {len(uuid_list)} camera calibrations")

    # Setup projector
    projector = Projector()

    # Load dataset
    droid_path = '/mnt/kevin/data/droid/droid/1.0.0'
    print("Loading DROID dataset...")
    builder = tfds.builder_from_directory(droid_path)
    dataset = builder.as_dataset(split='train')

    # Process only episodes in chunk
    processed_count = 0
    skipped_count = 0
    preview_count = 0

    pbar = tqdm(total=len(episode_indices_set), desc=label)

    for episode_idx, episode in enumerate(dataset):
        # Skip episodes not in this chunk
        if episode_idx not in episode_indices_set:
            continue

        # Check if already processed
        npz_path = data_dir / f"episode_{episode_idx:06d}.npz"
        if npz_path.exists():
            processed_count += 1
            pbar.update(1)
            continue

        # Find calibration
        uuid = find_closest_calibration(episode, uuid_list)
        if uuid is None or not calib_loader.has_refined_extrinsics(uuid):
            skipped_count += 1
            episode_indices_set.remove(episode_idx)
            pbar.update(1)
            continue

        # Process episode
        try:
            save_preview = (preview_count < args.save_previews)

            result = process_episode(
                episode, episode_idx, uuid, calib_loader, projector,
                cotracker, device, args.max_frames, save_preview, output_dir
            )

            if result is not None:
                # Save as NPZ
                np.savez_compressed(
                    npz_path,
                    episode_idx=result['episode_idx'],
                    tracked_points_exterior=result['tracks_exterior'],
                    tracked_points_wrist=result['tracks_wrist'],
                    tracks_vis_exterior=result['tracks_vis_exterior'],
                    tracks_vis_wrist=result['tracks_vis_wrist'],
                    images_exterior=result['images_exterior'],
                    images_wrist=result['images_wrist'],
                    actions=result['actions'],
                    uuid=uuid
                )
                processed_count += 1

                if save_preview:
                    preview_count += 1
            else:
                skipped_count += 1

        except Exception as e:
            print(f"\nError processing episode {episode_idx}: {e}")
            skipped_count += 1

        pbar.update(1)

        # Early exit if all episodes processed
        if processed_count + skipped_count >= len(chunk_data['episode_indices']):
            break

    pbar.close()

    # Save metadata
    metadata = {
        'chunk_id': chunk_id,
        'chunk_file': str(args.chunk_file),
        'processed': processed_count,
        'skipped': skipped_count,
        'total': len(chunk_data['episode_indices'])
    }

    metadata_path = output_dir / f'metadata_chunk_{chunk_id:02d}.json'
    with open(metadata_path, 'w') as f:
        json.dump(metadata, f, indent=2)

    print("\n" + "="*80)
    print("Preprocessing Complete")
    print("="*80)
    print(f"  Processed: {processed_count} episodes")
    print(f"  Skipped: {skipped_count} episodes")
    print(f"  Preview videos: {preview_dir}")
    print(f"  NPZ data: {data_dir}")
    print(f"  Metadata: {metadata_path}")
    print("="*80)

if __name__ == '__main__':
    main()

	#!/usr/bin/env python3
	"""
	Process a specific chunk of DROID episodes.
	Reads chunk file with episode indices and processes only those episodes.
	"""

	import json
	from pathlib import Path
	import tensorflow_datasets as tfds
	from tqdm import tqdm
	import torch
	import numpy as np
	import cv2
	from droid.calibration.calibration_loader import CalibrationLoader
	from droid.misc.projector import Projector

	# Import preprocessing functions from the main script
	import sys
	sys.path.insert(0, str(Path(__file__).parent))

	# Copy necessary functions
	def find_closest_calibration(episode, uuid_list):
	"""Find closest calibration UUID by timestamp."""
	ts = float(episode['episode_metadata']['recording_timestamp'].numpy())
	closest_uuid = None
	min_diff = float('inf')
	for uuid, calib_ts in uuid_list:
	diff = abs(ts - calib_ts)
	if diff < min_diff:
	min_diff = diff
	closest_uuid = uuid
	return closest_uuid

	def sample_arm_shaped_points(mesh_2d_visible, img_h, img_w, num_points=993, seed=0):
	"""Sample points in arm-shaped region excluding mesh vertices."""
	np.random.seed(seed)
	u_coords = []
	v_coords = []

	mesh_u = mesh_2d_visible[:, 0]
	mesh_v = mesh_2d_visible[:, 1]

	u_min = max(0, int(mesh_u.min()) - 50)
	u_max = min(img_w, int(mesh_u.max()) + 50)
	v_min = max(0, int(mesh_v.min()) - 50)
	v_max = min(img_h, int(mesh_v.max()) + 50)

	attempts = 0
	max_attempts = num_points * 100

	while len(u_coords) < num_points and attempts < max_attempts:
	u = np.random.randint(u_min, u_max)
	v = np.random.randint(v_min, v_max)

	# Check distance from mesh vertices
	dists = np.sqrt((mesh_u - u)2 + (mesh_v - v)2)
	if dists.min() > 10:
	u_coords.append(u)
	v_coords.append(v)

	attempts += 1

	if len(u_coords) < num_points:
	remaining = num_points - len(u_coords)
	u_coords.extend([img_w // 2] * remaining)
	v_coords.extend([img_h // 2] * remaining)

	return np.array(u_coords), np.array(v_coords)

	def sample_wrist_points(img_h, img_w, num_sparse=300, num_dense=700, seed=0):
	"""Sample wrist camera points with dense sampling in bottom region."""
	np.random.seed(seed)

	# Sparse uniform sampling
	u_sparse = np.random.randint(0, img_w, num_sparse)
	v_sparse = np.random.randint(0, img_h, num_sparse)

	# Dense sampling in bottom 60%-100%
	v_min_dense = int(img_h * 0.6)
	u_dense = np.random.randint(0, img_w, num_dense)
	v_dense = np.random.randint(v_min_dense, img_h, num_dense)

	u_all = np.concatenate([u_sparse, u_dense])
	v_all = np.concatenate([v_sparse, v_dense])

	return u_all, v_all

	def load_cotracker():
	"""Load CoTracker v3 offline model."""
	from cotracker.predictor import CoTrackerPredictor
	device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

	cotracker_paths = [
	'/mnt/kevin/vlm_models/cotracker/scaled_offline.pth',
	'/mnt/kevin/vlm_models/hub/checkpoints/scaled_offline.pth',
	'/root/workspace/code/wmrl/Dual-Dynamics-Models/DROID-main/co-tracker/checkpoints/scaled_offline.pth',
	]

	cotracker_checkpoint = None
	for path in cotracker_paths:
	if Path(path).exists():
	cotracker_checkpoint = path
	print(f"Found CoTracker checkpoint: {cotracker_checkpoint}")
	break

	if cotracker_checkpoint is None:
	raise FileNotFoundError(f"CoTracker checkpoint not found. Tried:\n" + "\n".join(cotracker_paths))

	cotracker = CoTrackerPredictor(checkpoint=cotracker_checkpoint)
	cotracker = cotracker.to(device)
	cotracker.eval()
	return cotracker, device

	def process_episode(episode, episode_idx, uuid, calib_loader, projector, cotracker, device,
	max_frames=400, save_preview=False, output_dir=None):
	"""Process a single episode."""

	# ... [Copy full function from preprocess_droid_rlds_final.py]
	# I'll use the existing implementation
	from preprocess_droid_rlds_final import process_episode as original_process_episode
	return original_process_episode(
	episode, episode_idx, uuid, calib_loader, projector, cotracker, device,
	max_frames, save_preview, output_dir
	)

	def main():
	import argparse
	parser = argparse.ArgumentParser()
	parser.add_argument('--chunk-file', type=str, required=True,
	help='Chunk JSON file with episode indices to process')
	parser.add_argument('--output-dir', type=str, default='/mnt/kevin/data/droid_processed_1000pts',
	help='Output directory')
	parser.add_argument('--max-frames', type=int, default=400,
	help='Max frames per episode')
	parser.add_argument('--save-previews', type=int, default=3,
	help='Number of preview videos to save')
	parser.add_argument('--chunk-id', type=int, default=None,
	help='Chunk ID for logging')
	args = parser.parse_args()

	# Load chunk data
	with open(args.chunk_file) as f:
	chunk_data = json.load(f)

	chunk_id = chunk_data['chunk_id'] if args.chunk_id is None else args.chunk_id
	episode_indices_set = set(chunk_data['episode_indices'])

	label = f"Chunk {chunk_id}"

	print("="*80)
	print(f"DROID Preprocessing: {label}")
	print("="*80)
	print(f" Chunk file: {args.chunk_file}")
	print(f" Episodes to process: {len(episode_indices_set)}")
	print(f" Output: {args.output_dir}")
	print("="*80)

	# Setup output directories
	output_dir = Path(args.output_dir)
	data_dir = output_dir / 'data'
	preview_dir = output_dir / 'preview_videos'
	data_dir.mkdir(parents=True, exist_ok=True)
	preview_dir.mkdir(parents=True, exist_ok=True)

	# Load CoTracker
	cotracker, device = load_cotracker()

	# Load camera calibrations
	calib_loader = CalibrationLoader()
	uuid_list = [(uuid, calib_loader.get_timestamp(uuid))
	for uuid in calib_loader.list_calibrations()]
	print(f"Loaded {len(uuid_list)} camera calibrations")

	# Setup projector
	projector = Projector()

	# Load dataset
	droid_path = '/mnt/kevin/data/droid/droid/1.0.0'
	print("Loading DROID dataset...")
	builder = tfds.builder_from_directory(droid_path)
	dataset = builder.as_dataset(split='train')

	# Process only episodes in chunk
	processed_count = 0
	skipped_count = 0
	preview_count = 0

	pbar = tqdm(total=len(episode_indices_set), desc=label)

	for episode_idx, episode in enumerate(dataset):
	# Skip episodes not in this chunk
	if episode_idx not in episode_indices_set:
	continue

	# Check if already processed
	npz_path = data_dir / f"episode_{episode_idx:06d}.npz"
	if npz_path.exists():
	processed_count += 1
	pbar.update(1)
	continue

	# Find calibration
	uuid = find_closest_calibration(episode, uuid_list)
	if uuid is None or not calib_loader.has_refined_extrinsics(uuid):
	skipped_count += 1
	episode_indices_set.remove(episode_idx)
	pbar.update(1)
	continue

	# Process episode
	try:
	save_preview = (preview_count < args.save_previews)

	result = process_episode(
	episode, episode_idx, uuid, calib_loader, projector,
	cotracker, device, args.max_frames, save_preview, output_dir
	)

	if result is not None:
	# Save as NPZ
	np.savez_compressed(
	npz_path,
	episode_idx=result['episode_idx'],
	tracked_points_exterior=result['tracks_exterior'],
	tracked_points_wrist=result['tracks_wrist'],
	tracks_vis_exterior=result['tracks_vis_exterior'],
	tracks_vis_wrist=result['tracks_vis_wrist'],
	images_exterior=result['images_exterior'],
	images_wrist=result['images_wrist'],
	actions=result['actions'],
	uuid=uuid
	)
	processed_count += 1

	if save_preview:
	preview_count += 1
	else:
	skipped_count += 1

	except Exception as e:
	print(f"\nError processing episode {episode_idx}: {e}")
	skipped_count += 1

	pbar.update(1)

	# Early exit if all episodes processed
	if processed_count + skipped_count >= len(chunk_data['episode_indices']):
	break

	pbar.close()

	# Save metadata
	metadata = {
	'chunk_id': chunk_id,
	'chunk_file': str(args.chunk_file),
	'processed': processed_count,
	'skipped': skipped_count,
	'total': len(chunk_data['episode_indices'])
	}

	metadata_path = output_dir / f'metadata_chunk_{chunk_id:02d}.json'
	with open(metadata_path, 'w') as f:
	json.dump(metadata, f, indent=2)

	print("\n" + "="*80)
	print("Preprocessing Complete")
	print("="*80)
	print(f" Processed: {processed_count} episodes")
	print(f" Skipped: {skipped_count} episodes")
	print(f" Preview videos: {preview_dir}")
	print(f" NPZ data: {data_dir}")
	print(f" Metadata: {metadata_path}")
	print("="*80)

	if __name__ == '__main__':
	main()