Datasets:

Neptune-T
/

DragMesh-3-Scene

#!/usr/bin/env python
"""Convert a generated scene into robot-executable poses.
This is the Policy Interface stage of the robot evaluation pipeline. It converts
a natural language task into concrete object IDs and exact poses that a robot
policy can execute.
The unified PolicyInterfaceAgent:
1. Parses the task → goal predicates + preconditions
2. Finds objects in scene matching categories
3. Verifies preconditions using state/vision tools
4. Returns ranked valid (target, reference) bindings
5. Computes exact poses for each binding
Usage:
    python scripts/robot_eval/policy_interface.py \
        --scene-state outputs/.../scene_002/combined_house/house_state.json \
        --dmd outputs/.../scene_002/combined_house/house.dmd.yaml \
        --scene-dir outputs/.../scene_002 \
        --task "Find a speaker and place it on the bed" \
        --door-clearance-m 1.0
Inputs:
    --scene-state: Path to scene_state.json (per-room) or house_state.json (combined house)
    --dmd: Path to scene.dmd.yaml or house.dmd.yaml (Drake scene with poses)
    --scene-dir: Scene root directory for package:// URI resolution (default: parent of DMD)
    --door-clearance-m: Distance from door for robot start position (default: 1.0)
Output:
    JSON with robot_start_xy and robot-executable commands with target poses.
"""

import argparse
import asyncio
import json
import logging

from pathlib import Path

from scenesmith.agent_utils.blender import BlenderServer
from scenesmith.robot_eval import create_robot_eval_config
from scenesmith.robot_eval.dmd_scene import load_scene_for_validation
from scenesmith.robot_eval.policy_interface.predicate_resolver import PredicateResolver

logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
logger = logging.getLogger(__name__)

# Outward normal vectors for each wall direction (robot faces into the room).
OUTWARD_NORMALS = {
    "north": (0.0, 1.0),
    "south": (0.0, -1.0),
    "east": (1.0, 0.0),
    "west": (-1.0, 0.0),
}


def compute_robot_start_xy(
    raw_state: dict, door_clearance_m: float
) -> tuple[float, float] | None:
    """Compute robot start XY from exterior door position.
    For house scenes with exterior doors, places the robot centered at the door
    and offset outward by door_clearance_m. For scenes without exterior doors,
    falls back to room center.
    Args:
        raw_state: Raw scene state dict (house_state.json or scene_state.json).
        door_clearance_m: Distance from door center to robot position.
    Returns:
        (x, y) start position in world coordinates, or None if cannot compute.
    """
    layout = raw_state.get("layout")
    if layout is None:
        logger.debug("No layout in scene state, cannot compute robot start position")
        return None

    placed_rooms = layout.get("placed_rooms", [])
    doors = layout.get("doors", [])

    exterior_door = next((d for d in doors if d.get("door_type") == "exterior"), None)
    if exterior_door is None:
        # Fall back to room center.
        if placed_rooms:
            room = placed_rooms[0]
            pos = room["position"]
            center_x = pos[0] + room["width"] / 2
            center_y = pos[1] + room["depth"] / 2
            logger.info(
                "No exterior door found, using room center: "
                f"({center_x:.2f}, {center_y:.2f})"
            )
            return (center_x, center_y)
        logger.warning(
            "No exterior door and no placed rooms, cannot compute start position"
        )
        return None

    # Find the room and wall containing the door.
    room_id = exterior_door["room_a"]
    door_id = exterior_door["id"]
    target_room = next((r for r in placed_rooms if r["room_id"] == room_id), None)
    if target_room is None:
        logger.warning(f"Room {room_id} not found in placed_rooms")
        return None

    # Find wall with this door opening.
    target_wall = next(
        (
            wall
            for wall in target_room.get("walls", [])
            if any(o.get("opening_id") == door_id for o in wall.get("openings", []))
        ),
        None,
    )
    if target_wall is None:
        logger.warning(f"Wall containing door {door_id} not found")
        return None

    # Compute door center position along wall.
    door_position_exact = exterior_door["position_exact"]
    door_width = exterior_door.get("width", 1.0)
    door_center_along_wall = door_position_exact + door_width / 2

    # Interpolate along wall to get world position.
    start_point = target_wall["start_point"]
    end_point = target_wall["end_point"]
    wall_length = target_wall["length"]

    if wall_length <= 0:
        logger.warning(f"Invalid wall length: {wall_length}")
        return None

    t = door_center_along_wall / wall_length
    door_center_x = start_point[0] + t * (end_point[0] - start_point[0])
    door_center_y = start_point[1] + t * (end_point[1] - start_point[1])

    # Get outward normal and compute robot position.
    direction = target_wall["direction"]
    outward = OUTWARD_NORMALS.get(direction)
    if outward is None:
        logger.warning(f"Unknown wall direction: {direction}")
        return None

    robot_x = door_center_x + door_clearance_m * outward[0]
    robot_y = door_center_y + door_clearance_m * outward[1]

    logger.info(
        f"Robot start position: ({robot_x:.2f}, {robot_y:.2f}) "
        f"[{door_clearance_m}m from {direction} door {door_id}]"
    )
    return (robot_x, robot_y)


def compute_world_bounds(
    raw_state: dict, inflation_m: float = 2.0
) -> dict[str, list[float]] | None:
    """Compute world bounds from room geometry, inflated by given distance.
    For sampling-based motion planners that need bounded degrees of freedom.
    Args:
        raw_state: Raw scene state dict (house_state.json or scene_state.json).
        inflation_m: Distance to inflate XY bounds by (default: 2.0m).
    Returns:
        Dict with "min" and "max" keys containing [x, y, z] coordinates,
        or None if cannot compute.
    """
    layout = raw_state.get("layout")
    if layout is None:
        return None

    placed_rooms = layout.get("placed_rooms", [])
    if not placed_rooms:
        return None

    # Get ceiling height (z max). Floor is at z=0.
    wall_height = layout.get("wall_height", 2.7)

    # Compute union of all room bounds.
    all_min_x, all_min_y = float("inf"), float("inf")
    all_max_x, all_max_y = float("-inf"), float("-inf")

    for room in placed_rooms:
        pos = room["position"]
        room_min_x = pos[0]
        room_min_y = pos[1]
        room_max_x = pos[0] + room["width"]
        room_max_y = pos[1] + room["depth"]

        all_min_x = min(all_min_x, room_min_x)
        all_min_y = min(all_min_y, room_min_y)
        all_max_x = max(all_max_x, room_max_x)
        all_max_y = max(all_max_y, room_max_y)

    # Inflate XY by specified distance. Z goes from floor (0) to ceiling.
    return {
        "min": [all_min_x - inflation_m, all_min_y - inflation_m, 0.0],
        "max": [all_max_x + inflation_m, all_max_y + inflation_m, wall_height],
    }


async def main():
    parser = argparse.ArgumentParser(
        description="Convert scene + task into robot-executable poses"
    )
    parser.add_argument(
        "--scene-state",
        required=True,
        type=Path,
        help="Path to scene_state.json (object metadata)",
    )
    parser.add_argument(
        "--dmd",
        required=True,
        type=Path,
        help="Path to scene.dmd.yaml (Drake scene)",
    )
    parser.add_argument(
        "--task",
        required=True,
        help="Human task description (e.g., 'Find a fruit and place it on the table')",
    )
    parser.add_argument(
        "--model",
        default="gpt-5.2",
        help="Model for policy interface agent (default: gpt-5.2)",
    )
    parser.add_argument(
        "--output-json",
        type=Path,
        help="Optional: Write robot commands to JSON file",
    )
    parser.add_argument(
        "--scene-dir",
        type=Path,
        help="Scene root directory for package:// URI resolution (default: parent of DMD)",
    )
    parser.add_argument(
        "--door-clearance-m",
        type=float,
        default=1.0,
        help="Distance from door for robot start position (default: 1.0)",
    )
    parser.add_argument(
        "--no-vision",
        action="store_true",
        help="Disable vision tools (skip Blender server startup)",
    )
    args = parser.parse_args()

    cfg = create_robot_eval_config(model=args.model)

    # Load scene.
    logger.info(f"Task: {args.task}")
    logger.info(f"Model: {args.model}")
    logger.info(f"Scene state: {args.scene_state}")
    logger.info(f"DMD: {args.dmd}")
    if args.scene_dir:
        logger.info(f"Scene dir: {args.scene_dir}")

    # Load raw state to compute robot start position and world bounds.
    with open(args.scene_state) as f:
        raw_state = json.load(f)
    robot_start_xy = compute_robot_start_xy(raw_state, args.door_clearance_m)
    world_bounds = compute_world_bounds(raw_state, inflation_m=2.0)

    scene = load_scene_for_validation(
        scene_state_path=args.scene_state,
        dmd_path=args.dmd,
        task_description=args.task,
        scene_dir=args.scene_dir,
    )
    scene.finalize()

    # Start Blender server for vision tools (unless disabled).
    blender_server = None
    if not args.no_vision:
        logger.info("Starting Blender server for vision tools...")
        blender_server = BlenderServer()
        blender_server.start()

    try:
        # Resolve task to poses using unified agent.
        logger.info("Resolving task with policy interface agent...")
        resolver = PredicateResolver(
            scene=scene, cfg=cfg, blender_server=blender_server
        )
        result = await resolver.resolve_async(task_description=args.task)

        for note in result.notes:
            logger.info(f"  {note}")

        logger.info("")
        logger.info("=" * 60)
        logger.info("ROBOT OUTPUT")
        logger.info("=" * 60)

        if robot_start_xy:
            logger.info(
                f"Robot start XY: [{robot_start_xy[0]:.4f}, {robot_start_xy[1]:.4f}]"
            )
        else:
            logger.info("Robot start XY: None (could not compute)")

        if world_bounds:
            logger.info(
                f"World bounds: [{world_bounds['min'][0]:.2f}, "
                f"{world_bounds['min'][1]:.2f}, {world_bounds['min'][2]:.2f}] → "
                f"[{world_bounds['max'][0]:.2f}, {world_bounds['max'][1]:.2f}, "
                f"{world_bounds['max'][2]:.2f}]"
            )

        logger.info("")
        logger.info("Commands:")
        robot_commands = []
        for exact in result.poses:
            pos = exact.target_position
            cmd = {
                "action": exact.action,
                "rank": exact.rank,
                "confidence": exact.confidence,
                "drake_model_name": exact.drake_model_name,
                "target_position": [round(p, 4) for p in pos],
                "placement_bounds_min": (
                    [round(p, 4) for p in exact.placement_bounds_min]
                    if exact.placement_bounds_min
                    else None
                ),
                "placement_bounds_max": (
                    [round(p, 4) for p in exact.placement_bounds_max]
                    if exact.placement_bounds_max
                    else None
                ),
                "reasoning": exact.reasoning,
            }
            robot_commands.append(cmd)
            logger.info(
                f"  rank={exact.rank} conf={exact.confidence:.2f}: "
                f"{exact.action}({exact.drake_model_name}) → "
                f"position [{pos[0]:.4f}, {pos[1]:.4f}, {pos[2]:.4f}]"
            )
            if exact.reasoning:
                logger.info(f"    reasoning: {exact.reasoning}")
            if exact.placement_bounds_min and exact.placement_bounds_max:
                bounds_min = exact.placement_bounds_min
                bounds_max = exact.placement_bounds_max
                logger.info(
                    f"    placement region: [{bounds_min[0]:.3f}, {bounds_min[1]:.3f}, {bounds_min[2]:.3f}] → "
                    f"[{bounds_max[0]:.3f}, {bounds_max[1]:.3f}, {bounds_max[2]:.3f}]"
                )

        if args.output_json:
            args.output_json.parent.mkdir(parents=True, exist_ok=True)
            output = {
                "task": args.task,
                "robot_start_xy": list(robot_start_xy) if robot_start_xy else None,
                "world_bounds": world_bounds,
                "commands": robot_commands,
            }
            with open(args.output_json, "w") as f:
                json.dump(output, f, indent=2)
            logger.info(f"Robot output written to: {args.output_json}")
    finally:
        if blender_server is not None:
            logger.info("Stopping Blender server...")
            blender_server.stop()


if __name__ == "__main__":
    asyncio.run(main())

	#!/usr/bin/env python
	"""Convert a generated scene into robot-executable poses.

	This is the Policy Interface stage of the robot evaluation pipeline. It converts
	a natural language task into concrete object IDs and exact poses that a robot
	policy can execute.

	The unified PolicyInterfaceAgent:
	1. Parses the task → goal predicates + preconditions
	2. Finds objects in scene matching categories
	3. Verifies preconditions using state/vision tools
	4. Returns ranked valid (target, reference) bindings
	5. Computes exact poses for each binding

	Usage:
	python scripts/robot_eval/policy_interface.py \
	--scene-state outputs/.../scene_002/combined_house/house_state.json \
	--dmd outputs/.../scene_002/combined_house/house.dmd.yaml \
	--scene-dir outputs/.../scene_002 \
	--task "Find a speaker and place it on the bed" \
	--door-clearance-m 1.0

	Inputs:
	--scene-state: Path to scene_state.json (per-room) or house_state.json (combined house)
	--dmd: Path to scene.dmd.yaml or house.dmd.yaml (Drake scene with poses)
	--scene-dir: Scene root directory for package:// URI resolution (default: parent of DMD)
	--door-clearance-m: Distance from door for robot start position (default: 1.0)

	Output:
	JSON with robot_start_xy and robot-executable commands with target poses.
	"""

	import argparse
	import asyncio
	import json
	import logging

	from pathlib import Path

	from scenesmith.agent_utils.blender import BlenderServer
	from scenesmith.robot_eval import create_robot_eval_config
	from scenesmith.robot_eval.dmd_scene import load_scene_for_validation
	from scenesmith.robot_eval.policy_interface.predicate_resolver import PredicateResolver

	logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
	logger = logging.getLogger(__name__)

	# Outward normal vectors for each wall direction (robot faces into the room).
	OUTWARD_NORMALS = {
	"north": (0.0, 1.0),
	"south": (0.0, -1.0),
	"east": (1.0, 0.0),
	"west": (-1.0, 0.0),
	}


	def compute_robot_start_xy(
	raw_state: dict, door_clearance_m: float
	) -> tuple[float, float] \| None:
	"""Compute robot start XY from exterior door position.

	For house scenes with exterior doors, places the robot centered at the door
	and offset outward by door_clearance_m. For scenes without exterior doors,
	falls back to room center.

	Args:
	raw_state: Raw scene state dict (house_state.json or scene_state.json).
	door_clearance_m: Distance from door center to robot position.

	Returns:
	(x, y) start position in world coordinates, or None if cannot compute.
	"""
	layout = raw_state.get("layout")
	if layout is None:
	logger.debug("No layout in scene state, cannot compute robot start position")
	return None

	placed_rooms = layout.get("placed_rooms", [])
	doors = layout.get("doors", [])

	exterior_door = next((d for d in doors if d.get("door_type") == "exterior"), None)
	if exterior_door is None:
	# Fall back to room center.
	if placed_rooms:
	room = placed_rooms[0]
	pos = room["position"]
	center_x = pos[0] + room["width"] / 2
	center_y = pos[1] + room["depth"] / 2
	logger.info(
	"No exterior door found, using room center: "
	f"({center_x:.2f}, {center_y:.2f})"
	)
	return (center_x, center_y)
	logger.warning(
	"No exterior door and no placed rooms, cannot compute start position"
	)
	return None

	# Find the room and wall containing the door.
	room_id = exterior_door["room_a"]
	door_id = exterior_door["id"]
	target_room = next((r for r in placed_rooms if r["room_id"] == room_id), None)
	if target_room is None:
	logger.warning(f"Room {room_id} not found in placed_rooms")
	return None

	# Find wall with this door opening.
	target_wall = next(
	(
	wall
	for wall in target_room.get("walls", [])
	if any(o.get("opening_id") == door_id for o in wall.get("openings", []))
	),
	None,
	)
	if target_wall is None:
	logger.warning(f"Wall containing door {door_id} not found")
	return None

	# Compute door center position along wall.
	door_position_exact = exterior_door["position_exact"]
	door_width = exterior_door.get("width", 1.0)
	door_center_along_wall = door_position_exact + door_width / 2

	# Interpolate along wall to get world position.
	start_point = target_wall["start_point"]
	end_point = target_wall["end_point"]
	wall_length = target_wall["length"]

	if wall_length <= 0:
	logger.warning(f"Invalid wall length: {wall_length}")
	return None

	t = door_center_along_wall / wall_length
	door_center_x = start_point[0] + t * (end_point[0] - start_point[0])
	door_center_y = start_point[1] + t * (end_point[1] - start_point[1])

	# Get outward normal and compute robot position.
	direction = target_wall["direction"]
	outward = OUTWARD_NORMALS.get(direction)
	if outward is None:
	logger.warning(f"Unknown wall direction: {direction}")
	return None

	robot_x = door_center_x + door_clearance_m * outward[0]
	robot_y = door_center_y + door_clearance_m * outward[1]

	logger.info(
	f"Robot start position: ({robot_x:.2f}, {robot_y:.2f}) "
	f"[{door_clearance_m}m from {direction} door {door_id}]"
	)
	return (robot_x, robot_y)


	def compute_world_bounds(
	raw_state: dict, inflation_m: float = 2.0
	) -> dict[str, list[float]] \| None:
	"""Compute world bounds from room geometry, inflated by given distance.

	For sampling-based motion planners that need bounded degrees of freedom.

	Args:
	raw_state: Raw scene state dict (house_state.json or scene_state.json).
	inflation_m: Distance to inflate XY bounds by (default: 2.0m).

	Returns:
	Dict with "min" and "max" keys containing [x, y, z] coordinates,
	or None if cannot compute.
	"""
	layout = raw_state.get("layout")
	if layout is None:
	return None

	placed_rooms = layout.get("placed_rooms", [])
	if not placed_rooms:
	return None

	# Get ceiling height (z max). Floor is at z=0.
	wall_height = layout.get("wall_height", 2.7)

	# Compute union of all room bounds.
	all_min_x, all_min_y = float("inf"), float("inf")
	all_max_x, all_max_y = float("-inf"), float("-inf")

	for room in placed_rooms:
	pos = room["position"]
	room_min_x = pos[0]
	room_min_y = pos[1]
	room_max_x = pos[0] + room["width"]
	room_max_y = pos[1] + room["depth"]

	all_min_x = min(all_min_x, room_min_x)
	all_min_y = min(all_min_y, room_min_y)
	all_max_x = max(all_max_x, room_max_x)
	all_max_y = max(all_max_y, room_max_y)

	# Inflate XY by specified distance. Z goes from floor (0) to ceiling.
	return {
	"min": [all_min_x - inflation_m, all_min_y - inflation_m, 0.0],
	"max": [all_max_x + inflation_m, all_max_y + inflation_m, wall_height],
	}


	async def main():
	parser = argparse.ArgumentParser(
	description="Convert scene + task into robot-executable poses"
	)
	parser.add_argument(
	"--scene-state",
	required=True,
	type=Path,
	help="Path to scene_state.json (object metadata)",
	)
	parser.add_argument(
	"--dmd",
	required=True,
	type=Path,
	help="Path to scene.dmd.yaml (Drake scene)",
	)
	parser.add_argument(
	"--task",
	required=True,
	help="Human task description (e.g., 'Find a fruit and place it on the table')",
	)
	parser.add_argument(
	"--model",
	default="gpt-5.2",
	help="Model for policy interface agent (default: gpt-5.2)",
	)
	parser.add_argument(
	"--output-json",
	type=Path,
	help="Optional: Write robot commands to JSON file",
	)
	parser.add_argument(
	"--scene-dir",
	type=Path,
	help="Scene root directory for package:// URI resolution (default: parent of DMD)",
	)
	parser.add_argument(
	"--door-clearance-m",
	type=float,
	default=1.0,
	help="Distance from door for robot start position (default: 1.0)",
	)
	parser.add_argument(
	"--no-vision",
	action="store_true",
	help="Disable vision tools (skip Blender server startup)",
	)
	args = parser.parse_args()

	cfg = create_robot_eval_config(model=args.model)

	# Load scene.
	logger.info(f"Task: {args.task}")
	logger.info(f"Model: {args.model}")
	logger.info(f"Scene state: {args.scene_state}")
	logger.info(f"DMD: {args.dmd}")
	if args.scene_dir:
	logger.info(f"Scene dir: {args.scene_dir}")

	# Load raw state to compute robot start position and world bounds.
	with open(args.scene_state) as f:
	raw_state = json.load(f)
	robot_start_xy = compute_robot_start_xy(raw_state, args.door_clearance_m)
	world_bounds = compute_world_bounds(raw_state, inflation_m=2.0)

	scene = load_scene_for_validation(
	scene_state_path=args.scene_state,
	dmd_path=args.dmd,
	task_description=args.task,
	scene_dir=args.scene_dir,
	)
	scene.finalize()

	# Start Blender server for vision tools (unless disabled).
	blender_server = None
	if not args.no_vision:
	logger.info("Starting Blender server for vision tools...")
	blender_server = BlenderServer()
	blender_server.start()

	try:
	# Resolve task to poses using unified agent.
	logger.info("Resolving task with policy interface agent...")
	resolver = PredicateResolver(
	scene=scene, cfg=cfg, blender_server=blender_server
	)
	result = await resolver.resolve_async(task_description=args.task)

	for note in result.notes:
	logger.info(f" {note}")

	logger.info("")
	logger.info("=" * 60)
	logger.info("ROBOT OUTPUT")
	logger.info("=" * 60)

	if robot_start_xy:
	logger.info(
	f"Robot start XY: [{robot_start_xy[0]:.4f}, {robot_start_xy[1]:.4f}]"
	)
	else:
	logger.info("Robot start XY: None (could not compute)")

	if world_bounds:
	logger.info(
	f"World bounds: [{world_bounds['min'][0]:.2f}, "
	f"{world_bounds['min'][1]:.2f}, {world_bounds['min'][2]:.2f}] → "
	f"[{world_bounds['max'][0]:.2f}, {world_bounds['max'][1]:.2f}, "
	f"{world_bounds['max'][2]:.2f}]"
	)

	logger.info("")
	logger.info("Commands:")
	robot_commands = []
	for exact in result.poses:
	pos = exact.target_position
	cmd = {
	"action": exact.action,
	"rank": exact.rank,
	"confidence": exact.confidence,
	"drake_model_name": exact.drake_model_name,
	"target_position": [round(p, 4) for p in pos],
	"placement_bounds_min": (
	[round(p, 4) for p in exact.placement_bounds_min]
	if exact.placement_bounds_min
	else None
	),
	"placement_bounds_max": (
	[round(p, 4) for p in exact.placement_bounds_max]
	if exact.placement_bounds_max
	else None
	),
	"reasoning": exact.reasoning,
	}
	robot_commands.append(cmd)
	logger.info(
	f" rank={exact.rank} conf={exact.confidence:.2f}: "
	f"{exact.action}({exact.drake_model_name}) → "
	f"position [{pos[0]:.4f}, {pos[1]:.4f}, {pos[2]:.4f}]"
	)
	if exact.reasoning:
	logger.info(f" reasoning: {exact.reasoning}")
	if exact.placement_bounds_min and exact.placement_bounds_max:
	bounds_min = exact.placement_bounds_min
	bounds_max = exact.placement_bounds_max
	logger.info(
	f" placement region: [{bounds_min[0]:.3f}, {bounds_min[1]:.3f}, {bounds_min[2]:.3f}] → "
	f"[{bounds_max[0]:.3f}, {bounds_max[1]:.3f}, {bounds_max[2]:.3f}]"
	)

	if args.output_json:
	args.output_json.parent.mkdir(parents=True, exist_ok=True)
	output = {
	"task": args.task,
	"robot_start_xy": list(robot_start_xy) if robot_start_xy else None,
	"world_bounds": world_bounds,
	"commands": robot_commands,
	}
	with open(args.output_json, "w") as f:
	json.dump(output, f, indent=2)
	logger.info(f"Robot output written to: {args.output_json}")
	finally:
	if blender_server is not None:
	logger.info("Stopping Blender server...")
	blender_server.stop()


	if __name__ == "__main__":
	asyncio.run(main())