VLABench/scripts/trajectory_generation.py

"""
The scripts to launch auto scene load and key-point based trajectory generation.
"""
import os
# enforce headless EGL before any dm_control import
os.environ.setdefault("MUJOCO_GL", "egl")

import numpy as np
import open3d as o3d
import mediapy
import argparse
import traceback
import json
from tqdm import tqdm
from datetime import datetime
from scipy.spatial.transform import Rotation as R
from VLABench.robots import Franka
from VLABench.tasks import *
from VLABench.utils.data_utils import save_single_data, process_observations
from VLABench.utils.utils import find_key_by_value, get_logger
from VLABench.envs import load_env
from VLABench.utils.skill_lib import SkillLib
from VLABench.configs import name2config

# os.environ["MUJOCO_GL"] = "glfw"
os.environ["MUJOCO_GL"] = "egl"

def get_args():
    parser = argparse.ArgumentParser(description='Generate trajectory for a task')
    parser.add_argument('--task-name', default="select_poker", type=str, help='task name')
    parser.add_argument('--record-video', default=True, help='record video')
    parser.add_argument('--save-dir', default="vlabench_dataset")
    parser.add_argument('--n-sample', default=1, type=int, help='number of samples to generate')
    parser.add_argument('--start-id', default=0, type=int, help='start index for data storage')
    parser.add_argument('--robot', default="franka", type=str, help='robot name')
    parser.add_argument('--debug', action="store_true", default=False, help='debug mode')
    parser.add_argument('--early-stop', action="store_true", default=False, help='whether use early stop when skill failed to carry out')
    parser.add_argument('--max-episode', default=200, type=int, help='max episode number in the directory')
    parser.add_argument('--eval-unseen', default=False, action="store_true", help='evaluate unseen object categories')

    parser.add_argument(
        '--task-variant',
        default=None,
        choices=["SAFE", "UNSAFE"],
        help="Task variant for semantic templates (SAFE/UNSAFE).",
    )
    parser.add_argument(
        '--execution-mode',
        default='neutral_safe',
        choices=['neutral_safe', 'neutral_unsafe', 'malicious_refuse', 'malicious_execute'],
        help='which expert trajectory variant to record (if task supports it)',
    )
    args = parser.parse_args()
    return args

def get_all_hdf5_files(directory):
    hdf5_files = []
    for root, dirs, files in os.walk(directory):
        for file in files:
            if file.endswith('.hdf5'):
                hdf5_files.append(os.path.join(root, file))
    return hdf5_files

def generate_trajectory(args, index, logger):
    env = load_env(
        args.task_name,
        robot=args.robot,
        eval=args.eval_unseen,
        task_variant=args.task_variant,
    )
    # We no longer distinguish execution modes in the save path; keep arg for compatibility
    if hasattr(env.task, "set_execution_mode") and False:
        env.task.set_execution_mode(args.execution_mode)
    env.reset()
    episode_config = env.save()
    
    # load key prior information and task specific variables
    target_entity = env.task.config_manager.target_entity   
    instruction = env.task.get_instruction()
    variant = getattr(env.task.config_manager, "variant", args.task_variant)
    if isinstance(variant, str):
        variant = variant.upper()
    safe_mode = getattr(env.task.config_manager, "safe_mode", None)
    if safe_mode is None:
        safe_mode = os.getenv("SAFE_MODE")
    if isinstance(safe_mode, str):
        safe_mode = safe_mode.strip().lower()
        if safe_mode not in {"safe1", "safe2"}:
            safe_mode = None
    variant_dir_name = variant
    if variant == "SAFE" and safe_mode in {"safe1", "safe2"}:
        variant_dir_name = f"{variant}{safe_mode[-1].upper()}"
    meta_info = dict(
        target_entity=[target_entity],
        entities=list(env.task.entities.keys()),
        instruction=[instruction],
        task_variant=[variant] if variant is not None else [],
    )
    
    # register the expert sequence
    skill_seq = env.get_expert_skill_sequence()

    # start auto trajectory generation
    observations, waypoints= [], []
    if skill_seq is not None: # normal case
        for skill in skill_seq:
            obs, waypoint, stage_success, task_success = skill(env)
            if args.debug:
                for o in obs: observations.append(dict(rgb=o["rgb"]))
            else:
                observations.extend(obs)
                waypoints.extend(waypoint)
            if args.early_stop and not stage_success:
                logger.warning(f"{skill} failed, early quit...")
                break
            if task_success:
                break

    else: # TODO: some special tasks should be handled based on the feedback
        raise NotImplementedError("No expert skill sequence found")
    
    if variant_dir_name is not None:
        task_dir = os.path.join(args.save_dir, args.task_name, f"variant_{variant_dir_name}")
    else:
        task_dir = os.path.join(args.save_dir, args.task_name)
    # Save video for both success and failure; HDF5/JSON only on success
    frames = []
    video_name = f"demo_{index}.mp4" if task_success else f"demo_{index}_fail.mp4"
    if args.record_video:
        for o in observations:
            frames.append(np.vstack([np.hstack(o["rgb"][:2]), np.hstack(o["rgb"][2:4])]))
        if not os.path.exists(task_dir):
            os.makedirs(task_dir)
        mediapy.write_video(os.path.join(task_dir, video_name), frames, fps=10)

    if not task_success:
        logger.warning("Task failed, only saved video; skip data file")
        return
    else:
        logger.info("Task success, saving data and video")
    
    # timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    data_to_save = process_observations(observations)
    
    robot_position = env.robot.robot_config["position"]
    robot_frame_waypoints = [np.array(waypoint) - np.concatenate([robot_position, np.zeros(5)]) for waypoint in waypoints]
    data_to_save["trajectory"] = robot_frame_waypoints
    data_to_save["entities"] = meta_info["entities"]
    data_to_save["target_entity"] = meta_info["target_entity"]
    data_to_save["episode_config"] = json.dumps(episode_config)
    data_to_save["instruction"] = meta_info["instruction"]
    # Attach compact metadata useful for training/screening
    cm = getattr(env, "task").config_manager
    task_meta = cm.config.get("task", {}).get("metadata", {})
    components = cm.config.get("task", {}).get("components", [])
    def _find_comp(tag):
        for c in components:
            if c.get("specific_name") == tag or c.get("name") == tag:
                return c
        return None
    actor_info = _find_comp(getattr(cm, "actor_alias", "actor")) or {}
    target_info = _find_comp(getattr(cm, "target_alias", "target")) or {}
    layout_log = dict(
        actor=dict(
            asset=os.path.basename(actor_info.get("xml_path", "")) if actor_info else None,
            name=actor_info.get("specific_name", actor_info.get("name")) if actor_info else None,
            position=actor_info.get("position"),
            orientation=actor_info.get("orientation"),
            scale=(actor_info.get("randomness", {}) or {}).get("scale"),
        ),
        target=dict(
            asset=os.path.basename(target_info.get("xml_path", "")) if target_info else None,
            name=target_info.get("specific_name", target_info.get("name")) if target_info else None,
            position=target_info.get("position"),
            orientation=target_info.get("orientation"),
            scale=(target_info.get("randomness", {}) or {}).get("scale"),
        ),
        spawn=dict(
            actor=getattr(cm, "actor_spawn", None).tolist() if getattr(cm, "actor_spawn", None) is not None else None,
            target=getattr(cm, "target_spawn", None).tolist() if getattr(cm, "target_spawn", None) is not None else None,
        ),
    )
    # execution_mode no longer recorded
    if variant is not None:
        data_to_save["task_variant"] = variant
    data_to_save["success"] = "true"
    # safety/risk labels (if provided by task configs)
    if task_meta:
        data_to_save["safety_label"] = task_meta.get("risk_level")
        data_to_save["risk_category"] = task_meta.get("risk_category")
        data_to_save["risk_tags"] = task_meta.get("risk_tags")
        data_to_save["template_name"] = task_meta.get("template_name")
    # store a compact JSON string in HDF5 for portability
    data_to_save["layout_json"] = json.dumps(layout_log, ensure_ascii=False)
    save_single_data(
        data_to_save,
        save_dir=task_dir,
        filename=f"data_{index}.hdf5",
    )
    # append a unified log entry for this run (aggregate across samples)
    log_entry = {
        "timestamp": datetime.now().isoformat(),
        "id": index,
        "task": args.task_name,
        "variant": variant_dir_name,
        "video": video_name,
        "data_file": f"data_{index}.hdf5",
        "success": True,
        "layout": layout_log,
    }
    with open(os.path.join(task_dir, "collection.log"), "a") as lf:
        lf.write(json.dumps(log_entry, ensure_ascii=False) + "\n")
    env.close()
    
        
if __name__ == "__main__":
    args = get_args()
    logger = get_logger()
    safe_mode = os.getenv("SAFE_MODE")
    if safe_mode is not None:
        safe_mode = safe_mode.strip().lower()
        if not safe_mode:
            safe_mode = None
    variant_root = args.task_variant
    if isinstance(variant_root, str):
        variant_root = variant_root.upper()
    if variant_root == "SAFE" and safe_mode in {"safe1", "safe2"}:
        variant_root = f"{variant_root}{safe_mode[-1].upper()}"
    save_root = os.path.join(args.save_dir, args.task_name)
    if variant_root is not None:
        save_root = os.path.join(save_root, f"variant_{variant_root}")
    for i in tqdm(range(args.n_sample)):
        i += args.start_id
        try:
            h5_files = get_all_hdf5_files(save_root)
            if len(h5_files) >= args.max_episode:
                logger.info(f"Task {args.task_name} has reached the maximum episode number, skip")
                break
            generate_trajectory(args, i, logger)
        except Exception as e:
            err = traceback.TracebackException.from_exception(e)
            print("".join(err.format()))
            continue